NetworkQueue: NQPeerList.cpp Source File

00001 #include "PlatformSW.h"
00002 #include <assert.h>
00003 #include "NQDeclarations.h"
00004 #include "NQPeerList.h"
00005 
00006 
00007 //
00008 // CNQPeerList constructor
00009 //
00010 //  initialization and memory allocation 
00011 //
00012 CNQPeerList::CNQPeerList() : CNQLockMechanism() 
00013 {
00014     INT32 maxsize = NQ_PEERLIST_MAX_SIZE; // # entries 
00015     m_iQueueMaxSize = maxsize;
00016 
00017     m_pQueueValue = new NQ_PEER_ENTRY_INT[maxsize];
00018     m_iQueueNextElement = new INT32[maxsize];
00019 
00020     m_iLastError = ERR_PL_NONE;
00021 
00022     for (int i=0;i<maxsize;i++)
00023     {
00024         m_pQueueValue[i].enabled = false;
00025         m_iQueueNextElement[i] = -1;
00026     }
00027 
00028     m_iQueueFirstElement = -1;
00029     m_iQueueLastElement = -1;
00030     m_iQueueNumElements = 0;
00031 }
00032 
00033 //
00034 // CNQPeerList destructor
00035 //
00036 //  mandatory deinitialization (free up memory)
00037 //
00038 CNQPeerList::~CNQPeerList() 
00039 {
00040     delete [] m_pQueueValue;
00041     delete [] m_iQueueNextElement;
00042 }
00043 
00044 
00045 
00046 //
00047 // convenience
00048 //
00049 
00050 bool CNQPeerList::add( UINT32 ip, UINT16 port )
00051 {
00052     UINT32 drop_lasterr;
00053     
00054     return add(ip, port, drop_lasterr);
00055 }
00056 
00057 bool CNQPeerList::remove( UINT32 ip, UINT16 port )
00058 {
00059     UINT32 drop_lasterr;
00060 
00061     return remove( ip, port, drop_lasterr );
00062 }
00063 
00064 bool CNQPeerList::removeAll()
00065 {
00066     UINT32 drop_lasterr;
00067 
00068     return removeAll( drop_lasterr );
00069 }
00070 
00071 /*not used at the moment, untested, removed from release SW! Aug 28, 2007
00072 bool CNQPeerList::find( UINT32 ip, UINT16 port)
00073 {
00074     UINT32 drop_lasterr;
00075 
00076     return find( ip, port, drop_lasterr );
00077 }*/
00078 
00079 /*not used at the moment, untested, removed from release SW! Aug 28, 2007
00080 bool CNQPeerList::getEntryByPos( UINT32 pos, UINT32 &ip, UINT32 &port)
00081 {
00082     UINT32 drop_lasterr;
00083 
00084     return getEntryByPos(ip, port, drop_lasterr);
00085 }*/
00086 
00087 bool CNQPeerList::isAllowed(UINT32 ip, UINT16 port)
00088 {
00089     UINT32 drop_lasterr;
00090     
00091     return isAllowed( ip, port, drop_lasterr);
00092 }
00093 
00094 bool CNQPeerList::getReceivePacketIndex( UINT32 ip, UINT16 port, UINT16 &packetindex)
00095 {
00096     UINT32 drop_lasterr;
00097     
00098     return getReceivePacketIndex( ip, port, packetindex, drop_lasterr);
00099 }
00100 
00101 bool CNQPeerList::setReceivePacketIndex( UINT32 ip, UINT16 port, UINT16 packetindex)
00102 {
00103     UINT32 drop_lasterr;
00104     
00105     return setReceivePacketIndex( ip, port, packetindex, drop_lasterr);
00106 }
00107 
00108 bool CNQPeerList::getSendPacketIndex( UINT32 ip, UINT16 port, UINT16 & aNextPacketIndex)
00109 {
00110     UINT32 drop_lasterr;
00111 
00112     return getSendPacketIndex( ip, port, aNextPacketIndex, drop_lasterr );
00113 }
00114 
00115 bool CNQPeerList::incSendPacketIndex( UINT32 ip, UINT16 port)
00116 {
00117     UINT32 drop_lasterr;
00118     
00119     return incSendPacketIndex( ip, port, drop_lasterr);
00120 }
00121 
00122 //
00123 // convenience END
00124 //
00125 
00126 //
00127 // CNQPeerList::add()
00128 //
00148 bool CNQPeerList::add( UINT32 ip, UINT16 port, UINT32 &lasterr)
00149 {
00150     if (!lock()) 
00151     {
00152         m_iLastError = lasterr = ERR_PL_LOCK;
00153         return false;
00154     }
00155     
00156     bool retval = false;
00157     
00158     INT32 it = m_iQueueFirstElement;
00159     
00160     if (m_iQueueNumElements != 0) 
00161     {
00162         while( it != -1)
00163         {
00164             assert( m_pQueueValue[it].enabled == true );
00165 
00166             if ((ip == m_pQueueValue[it].ip_host) && (port == m_pQueueValue[it].port_host))
00167             {
00168                 retval = true;
00169                 m_iLastError = lasterr = ERR_PL_NONE;
00170                 break;
00171             }
00172         
00173             it = m_iQueueNextElement[it];
00174         }
00175     }
00176     
00177     if (retval == false) // remote peer is not yet in list
00178     {
00179 
00180         // if queue full: dont append anything else
00181         if (m_iQueueNumElements >= m_iQueueMaxSize) 
00182         {
00183             assert( m_iQueueNumElements == m_iQueueMaxSize );
00184             m_iLastError = lasterr = ERR_PL_FULL;
00185         }
00186         else
00187         {
00188             INT32 free_index = -1;
00189 
00190             for (INT32 cur=0;cur<m_iQueueMaxSize;cur++)
00191             {
00192                 if (m_pQueueValue[cur].enabled == false) 
00193                 {
00194                     free_index = cur;
00195                     break;
00196                 }
00197             }
00198 
00199             assert( free_index != -1 );
00200         
00201             if (m_iQueueLastElement == -1)
00202             {
00203                 // queue is empty
00204                 m_iQueueFirstElement = free_index;
00205                 m_iQueueLastElement = free_index;
00206 
00207                 m_pQueueValue[free_index].enabled = true;
00208                 m_pQueueValue[free_index].ip_host = ip;
00209                 m_pQueueValue[free_index].port_host = port;
00210                 m_pQueueValue[free_index].receive_last_packet_index_set = false;
00211                 m_pQueueValue[free_index].send_packet_index = 1;
00212 
00213                 m_iQueueNextElement[free_index] = -1;
00214                 m_iQueueNumElements++;
00215             }
00216             else
00217             {
00218                 m_iQueueNextElement[m_iQueueLastElement] = free_index;
00219 
00220                 m_pQueueValue[free_index].enabled = true;
00221                 m_pQueueValue[free_index].ip_host = ip;
00222                 m_pQueueValue[free_index].port_host = port;
00223                 m_pQueueValue[free_index].receive_last_packet_index_set = false;
00224                 m_pQueueValue[free_index].send_packet_index = 1;
00225 
00226                 m_iQueueNextElement[free_index] = -1;
00227                 m_iQueueLastElement = free_index;
00228                 m_iQueueNumElements++;
00229             }
00230             
00231             m_iLastError = lasterr = ERR_PL_NONE;
00232             retval = true;
00233         }
00234     }
00235             
00236     unlock();
00237 
00238     return retval;
00239 }
00240 
00241 //
00242 // CNQPeerList::remove()
00243 //
00260 bool CNQPeerList::remove( UINT32 ip, UINT16 port, UINT32 &lasterr )
00261 {
00262     if (!lock()) 
00263     {
00264         m_iLastError = lasterr = ERR_PL_LOCK;
00265         return false;
00266     }
00267     
00268     INT32 found_index = m_iQueueFirstElement;
00269     INT32 last_index = -1;
00270     bool del = false;
00271     bool retval = false;
00272 
00273     while( found_index != -1)
00274     {
00275         assert( m_pQueueValue[found_index].enabled == true);
00276 
00277         if ((m_pQueueValue[found_index].ip_host == ip) && (m_pQueueValue[found_index].port_host == port)) 
00278         {
00279             if (last_index == -1)
00280             {
00281                 INT32 removeidx = m_iQueueFirstElement;
00282 
00283                 m_pQueueValue[removeidx].enabled = false;
00284                 m_iQueueFirstElement = m_iQueueNextElement[removeidx];
00285                 m_iQueueNumElements--;
00286 
00287                 if (m_iQueueNumElements == 0)
00288                 {
00289                     assert( m_iQueueFirstElement == -1 );
00290                     m_iQueueLastElement = -1;
00291                 }
00292 
00293                 del = true;
00294             }
00295             else
00296             {
00297                 INT32 removeidx = found_index;
00298 
00299                 m_pQueueValue[removeidx].enabled = false;
00300                 m_iQueueNextElement[last_index] = m_iQueueNextElement[removeidx];
00301                 m_iQueueNumElements--;
00302                 m_iQueueNextElement[removeidx] = -1;
00303 
00304                 if (m_iQueueNextElement[last_index] == -1)
00305                 {
00306                     m_iQueueLastElement = last_index;
00307                 }
00308 
00309                 del = true;
00310 
00311             }
00312         }
00313         
00314         if (del == true) break;
00315 
00316         last_index = found_index;
00317         found_index = m_iQueueNextElement[found_index];
00318     }
00319 
00320     if (del == true)
00321     {
00322         retval = true;
00323         m_iLastError = lasterr = ERR_PL_NONE;
00324     }
00325     else m_iLastError = lasterr = ERR_PL_NOTFOUND;
00326 
00327 
00328     unlock();
00329 
00330     return retval;
00331 }
00332 
00333 //
00334 // CNQPeerList::removeAll()
00335 //
00345 bool CNQPeerList::removeAll( UINT32 &lasterr )
00346 {
00347     if (!lock()) 
00348     {
00349         m_iLastError = lasterr = ERR_PL_LOCK;
00350         return false;
00351     }
00352 
00353 
00354     for (int i=0;i<m_iQueueMaxSize;i++)
00355     {
00356         m_pQueueValue[i].enabled = false;
00357         m_iQueueNextElement[i] = -1;
00358     }
00359 
00360     m_iQueueFirstElement = -1;
00361     m_iQueueLastElement = -1;
00362     m_iQueueNumElements = 0;
00363 
00364     unlock();
00365 
00366     return true;
00367 }
00368 
00369 
00370 //
00371 // CNQPeerList::count()
00372 //
00377 UINT32 CNQPeerList::count()
00378 {
00379     return( m_iQueueNumElements );
00380 
00381 }
00382 
00383 /* not used at the moment, untested, removed from release SW! Aug 28, 2007
00384 bool CNQPeerList::getEntryByPos( UINT32 pos, UINT32 &ip, UINT16 &port, UINT32 &lasterr)
00385 {
00386     if (!lock()) 
00387     {
00388         m_iLastError = lasterr = ERR_PL_LOCK;
00389         return false;
00390     }
00391 
00392     INT32 it = m_iQueueFirstElement;
00393     bool retval = false;
00394     UINT32 cnt=0;
00395 
00396     m_iLastError = lasterr = ERR_PL_NOTFOUND;
00397 
00398     if (m_iQueueNumElements == 0) return false;
00399 
00400     while( it != -1)
00401     {
00402         if (cnt == pos) 
00403         {
00404             assert( m_pQueueValue[it].enabled == true );
00405 
00406             ip = m_pQueueValue[it].ip_host;
00407             port = m_pQueueValue[it].port_host;
00408             retval = true;
00409             m_iLastError = lasterr = ERR_PL_NONE;
00410             break;
00411         }
00412         
00413         cnt++;
00414         it = m_iQueueNextElement[it];
00415     }
00416     
00417     unlock();
00418 
00419     return retval;
00420 }
00421 */
00422 /* not used at the moment, untested, removed from release SW! Aug 28, 2007
00423 bool CNQPeerList::find( UINT32 ip, UINT16 port, UINT32 &lasterr)
00424 {
00425     if (!lock()) 
00426     {
00427         m_iLastError = lasterr = ERR_PL_LOCK;
00428         return false;
00429     }
00430 
00431     INT32 it = m_iQueueFirstElement;
00432     bool retval = false;
00433 
00434     m_iLastError = lasterr = ERR_PL_NOTFOUND;
00435 
00436     if (m_iQueueNumElements != 0) 
00437     {
00438         while( it != -1)
00439         {
00440             assert( m_pQueueValue[it].enabled == true );
00441 
00442             if ((ip == m_pQueueValue[it].ip_host) && (port == m_pQueueValue[it].port_host))
00443             {
00444                 retval = true;
00445                 m_iLastError = lasterr = ERR_PL_NONE;
00446                 break;
00447             }
00448         
00449             it = m_iQueueNextElement[it];
00450         }
00451     }
00452     
00453     unlock();
00454 
00455     return retval;
00456 }
00457 */
00458 
00459 
00460 //
00461 // CNQPeerList::isAllowed()
00462 //
00482 bool CNQPeerList::isAllowed(UINT32 ip, UINT16 port, UINT32 &lasterr)
00483 {
00484     if (!lock()) 
00485     {
00486         m_iLastError = lasterr = ERR_PL_LOCK;
00487         return false;
00488     }
00489 
00490     INT32 it = m_iQueueFirstElement;
00491     bool retval = false;
00492 
00493     m_iLastError = lasterr = ERR_PL_NOTFOUND;
00494 
00495     while( it != -1)
00496     {
00497         assert( m_pQueueValue[it].enabled == true );
00498 
00499         if ((ip == m_pQueueValue[it].ip_host) && (port == m_pQueueValue[it].port_host))
00500         {
00501             retval = true;
00502             m_iLastError = lasterr = ERR_PL_NONE;
00503             break;
00504         }
00505         
00506         it = m_iQueueNextElement[it];
00507     }
00508     
00509     unlock();
00510 
00511     return retval;
00512 }
00513 
00514 //
00515 // CNQPeerList::getReceivePacketIndex()
00516 //
00538 bool CNQPeerList::getReceivePacketIndex( UINT32 ip, UINT16 port, UINT16 &packetindex, UINT32 &lasterr)
00539 {
00540     if (!lock()) 
00541     {
00542         m_iLastError = lasterr = ERR_PL_LOCK;
00543         return false;
00544     }
00545 
00546     INT32 it = m_iQueueFirstElement;
00547     bool retval = false;
00548 
00549     m_iLastError = lasterr = ERR_PL_NOTFOUND;
00550 
00551     while( it != -1)
00552     {
00553         assert( m_pQueueValue[it].enabled == true );
00554 
00555         if ((ip == m_pQueueValue[it].ip_host) && (port == m_pQueueValue[it].port_host))
00556         {
00557             if (m_pQueueValue[it].receive_last_packet_index_set == true)
00558             {
00559                 packetindex = m_pQueueValue[it].receive_last_packet_index;
00560                 retval = true;
00561                 m_iLastError = lasterr = ERR_PL_NONE;
00562                 break;
00563             }
00564             else
00565             {
00566                 m_iLastError = lasterr = ERR_PL_INDEXNOTSET;
00567                 break;
00568             }
00569         }
00570         
00571         it = m_iQueueNextElement[it];
00572     }
00573     
00574     unlock();
00575 
00576     return retval;
00577 }
00578 
00579 //
00580 // CNQPeerList::setReceivePacketIndex()
00581 //
00602 bool CNQPeerList::setReceivePacketIndex( UINT32 ip, UINT16 port, UINT16 packetindex, UINT32 &lasterr)
00603 {
00604     if (!lock()) 
00605     {
00606         m_iLastError = lasterr = ERR_PL_LOCK;
00607         return false;
00608     }
00609 
00610     INT32 it = m_iQueueFirstElement;
00611     bool retval = false;
00612 
00613     m_iLastError = lasterr = ERR_PL_NOTFOUND;
00614 
00615     while( it != -1)
00616     {
00617         assert( m_pQueueValue[it].enabled == true );
00618 
00619         if ((ip == m_pQueueValue[it].ip_host) && (port == m_pQueueValue[it].port_host))
00620         {
00621             m_pQueueValue[it].receive_last_packet_index = packetindex;
00622             m_pQueueValue[it].receive_last_packet_index_set = true;
00623             retval = true;
00624             m_iLastError = lasterr = ERR_PL_NONE;
00625             break;
00626         }
00627         
00628         it = m_iQueueNextElement[it];
00629     }
00630     
00631     unlock();
00632 
00633     return retval;
00634 }
00635 
00636 
00637 //
00638 // CNQPeerList::getSendPacketIndex()
00639 //
00657 bool CNQPeerList::getSendPacketIndex( UINT32 ip, UINT16 port, UINT16 & aNextPacketIndex, UINT32 &lasterr )
00658 {
00659     if (!lock()) 
00660     {
00661         m_iLastError = lasterr = ERR_PL_LOCK;
00662         return false;
00663     }
00664 
00665     INT32 it = m_iQueueFirstElement;
00666     bool retval = false;
00667 
00668     m_iLastError = lasterr = ERR_PL_NOTFOUND;
00669 
00670     while( it != -1)
00671     {
00672         assert( m_pQueueValue[it].enabled == true );
00673 
00674         if ((ip == m_pQueueValue[it].ip_host) && (port == m_pQueueValue[it].port_host))
00675         {
00676             aNextPacketIndex = m_pQueueValue[it].send_packet_index;
00677             retval = true;
00678             m_iLastError = lasterr = ERR_PL_NONE;
00679             break;
00680         }
00681         
00682         it = m_iQueueNextElement[it];
00683     }
00684     
00685     unlock();
00686 
00687     return retval;
00688 }
00689 
00690 //
00691 // CNQPeerList::incSendPacketIndex()
00692 //
00712 bool CNQPeerList::incSendPacketIndex( UINT32 ip, UINT16 port, UINT32 &lasterr)
00713 {
00714     if (!lock()) 
00715     {
00716         m_iLastError = lasterr = ERR_PL_LOCK;
00717         return false;
00718     }
00719 
00720     INT32 it = m_iQueueFirstElement;
00721     bool retval = false;
00722 
00723     m_iLastError = lasterr = ERR_PL_NOTFOUND;
00724 
00725     while( it != -1)
00726     {
00727         assert( m_pQueueValue[it].enabled == true );
00728 
00729         if ((ip == m_pQueueValue[it].ip_host) && (port == m_pQueueValue[it].port_host))
00730         {
00731             m_pQueueValue[it].send_packet_index++;
00732 
00733             retval = true;
00734             m_iLastError = lasterr = ERR_PL_NONE;
00735             break;
00736         }
00737         
00738         it = m_iQueueNextElement[it];
00739     }
00740     
00741     unlock();
00742 
00743     return retval;
00744 }
00745 
00752 UINT32 CNQPeerList::getLastError()
00753 {
00754     // be very careful: concurrent threads
00755     return( m_iLastError );
00756 }