Changeset 107

Show
Ignore:
Timestamp:
09/15/07 20:20:13 (1 year ago)
Author:
daboo
Message:

Fix some bad pointer arithmetic errors. This fixes crashes during drag and drop.

Location:
Mulberry/trunk/Linux/Sources/Application
Files:
9 modified

Legend:

Unmodified
Added
Removed

  • Mulberry/trunk/Linux/Sources/Application/Address_Book/CAddressTable.cp

    r54 r107  
    856856                { 
    857857                        // Copy to global after lock 
    858                         CAddress** pAddr = reinterpret_cast<CAddress**>(data); 
    859                         *((unsigned long*) pAddr) = addrs.size(); 
    860                         pAddr += sizeof(unsigned long); 
     858                        unsigned char* ptr = data; 
     859                        *((unsigned long*) ptr) = addrs.size(); 
     860                        ptr += sizeof(unsigned long); 
    861861                        for(CAddressList::iterator iter = addrs.begin(); iter != addrs.end(); iter++) 
    862                                 *pAddr++ = *iter; 
     862                        { 
     863                                *((CAddress**) ptr) = *iter; 
     864                                ptr += sizeof(CAddress*); 
     865                        } 
    863866 
    864867                        seldata->SetData(type, data, dataLength); 

  • Mulberry/trunk/Linux/Sources/Application/Address_Book/CGroupTable.cp

    r31 r107  
    12181218                { 
    12191219                        // Copy to global after lock 
    1220                         CGroup** pGrp = reinterpret_cast<CGroup**>(data); 
    1221                         *((unsigned long*) pGrp) = grps.size(); 
    1222                         pGrp += sizeof(unsigned long); 
     1220                        unsigned char* ptr = data; 
     1221                        *((unsigned long*) ptr) = grps.size(); 
     1222                        ptr += sizeof(unsigned long); 
    12231223                        for(CGroupList::iterator iter = grps.begin(); iter != grps.end(); iter++) 
    1224                                 *pGrp++ = *iter; 
     1224                        { 
     1225                                *((CGroup**) ptr) = *iter; 
     1226                                ptr += sizeof(CGroup*); 
     1227                        } 
    12251228 
    12261229                        seldata->SetData(type, data, dataLength); 
    … …  
    12461249                { 
    12471250                        // Copy to global after lock 
    1248                         CAddress** pAddr = reinterpret_cast<CAddress**>(data); 
    1249                         *((unsigned long*) pAddr) = addrs.size(); 
    1250                         pAddr += sizeof(unsigned long); 
     1251                        unsigned char* ptr = data; 
     1252                        *((unsigned long*) ptr) = addrs.size(); 
     1253                        ptr += sizeof(unsigned long); 
    12511254                        for(CAddressList::iterator iter = addrs.begin(); iter != addrs.end(); iter++) 
    1252                                 *pAddr++ = *iter; 
     1255                        { 
     1256                                *((CAddress**) ptr) = *iter; 
     1257                                ptr += sizeof(CAddress*); 
     1258                        } 
    12531259 
    12541260                        seldata->SetData(type, data, dataLength); 

  • Mulberry/trunk/Linux/Sources/Application/Address_Search/CAdbkSearchTable.cp

    r31 r107  
    624624                { 
    625625                        // Copy to global after lock 
    626                         CAddress** pAddr = reinterpret_cast<CAddress**>(data); 
    627                         *((unsigned long*) pAddr) = addrs.size(); 
    628                         pAddr += sizeof(unsigned long); 
     626                        unsigned char* ptr = data; 
     627                        *((unsigned long*) ptr) = addrs.size(); 
     628                        ptr += sizeof(unsigned long); 
    629629                        for(CAddressList::iterator iter = addrs.begin(); iter != addrs.end(); iter++) 
    630                                 *pAddr++ = *iter; 
     630                        { 
     631                                *((CAddress**) ptr) = *iter; 
     632                                ptr += sizeof(CAddress*); 
     633                        } 
    631634                         
    632635                        seldata->SetData(type, data, dataLength); 

  • Mulberry/trunk/Linux/Sources/Application/Calendar/Calendar_View/Calendar_Store_View/CCalendarStoreTable.cp

    r21 r107  
    891891                if (data) 
    892892                { 
    893                         int* i = reinterpret_cast<int*>(data); 
    894                         *i = count; 
    895                         i++; 
    896                         void** vdata = reinterpret_cast<void**>(i); 
     893                        unsigned char* ptr = data; 
     894                        *((int*) ptr) = count; 
     895                        ptr += sizeof(int); 
     896                        void** vdata = reinterpret_cast<void**>(ptr); 
    897897                        for(ulvector::const_iterator iter = rows.begin(); iter != rows.end(); iter++) 
    898898                        { 

  • Mulberry/trunk/Linux/Sources/Application/Letter/CFileTable.cp

    r21 r107  
    15661566                { 
    15671567                        // Copy to global after lock 
    1568                         CAttachment** pAddr = reinterpret_cast<CAttachment**>(data); 
    1569                         *((int*) pAddr) = atchs.size(); 
    1570                         pAddr += sizeof(int); 
     1568                        unsigned char* ptr = data; 
     1569                        *((int*) ptr) = atchs.size(); 
     1570                        ptr += sizeof(int); 
    15711571                        for(CAttachmentList::iterator iter = atchs.begin(); iter != atchs.end(); iter++) 
    1572                                 *pAddr++ = *iter; 
     1572                        { 
     1573                                *((CAttachment**) ptr) = *iter; 
     1574                                ptr += sizeof(CAttachment*); 
     1575                        } 
    15731576                         
    15741577                        seldata->SetData(type, data, dataLength); 

  • Mulberry/trunk/Linux/Sources/Application/Mailbox/CMailboxTable.cp

    r21 r107  
    14521452                { 
    14531453                        // Copy to global after lock 
    1454                         CMessage** pAddr = reinterpret_cast<CMessage**>(data); 
    1455                         *((int*) pAddr) = msgs.size(); 
    1456                         pAddr += sizeof(int); 
     1454                        unsigned char* ptr = data; 
     1455                        *((int*) ptr) = msgs.size(); 
     1456                        ptr += sizeof(int); 
    14571457                        for(CMessageList::iterator iter = msgs.begin(); iter != msgs.end(); iter++) 
    1458                                 *pAddr++ = *iter; 
    1459                          
     1458                        { 
     1459                                *((CMessage**) ptr) = *iter; 
     1460                                ptr += sizeof(CMessage*); 
     1461                        } 
    14601462                        seldata->SetData(type, data, dataLength); 
    14611463                        rendered = true; 

  • Mulberry/trunk/Linux/Sources/Application/Message/CBodyTable.cp

    r21 r107  
    738738                { 
    739739                        // Copy to global after lock 
    740                         CAttachment** pAddr = reinterpret_cast<CAttachment**>(data); 
    741                         *((CMessage**) pAddr) = (mWindow ? mWindow->GetMessage() : mView->GetMessage()); 
    742                         pAddr += sizeof(CMessage*); 
    743                         *((int*) pAddr) = attchs.size(); 
    744                         pAddr += sizeof(int); 
     740                        unsigned char* ptr = data; 
     741                        *((CMessage**) ptr) = (mWindow ? mWindow->GetMessage() : mView->GetMessage()); 
     742                        ptr += sizeof(CMessage*); 
     743                        *((int*) ptr) = attchs.size(); 
     744                        ptr += sizeof(int); 
    745745                        for(CAttachmentList::iterator iter = attchs.begin(); iter != attchs.end(); iter++) 
    746                                 *pAddr++ = *iter; 
     746                        { 
     747                                *((CAttachment**) ptr) = *iter; 
     748                                ptr += sizeof(CAttachment*); 
     749                        } 
    747750                         
    748751                        seldata->SetData(type, data, dataLength); 

  • Mulberry/trunk/Linux/Sources/Application/Rules/CRulesTable.cp

    r21 r107  
    329329                if (data) 
    330330                { 
    331                         CFilterItem** i = reinterpret_cast<CFilterItem**>(data); 
    332                         *((int*) i) = count; 
    333                         i += sizeof(int); 
     331                        unsigned char* ptr = data; 
     332                        *((int*) ptr) = count; 
     333                        ptr += sizeof(int); 
    334334                        for(CFilterItems::iterator iter = items.begin(); iter != items.end(); iter++) 
    335                                 *i++ = *iter; 
     335                        { 
     336                                *((CFilterItem**) ptr) = *iter; 
     337                                ptr += sizeof(CFilterItem*); 
     338                        } 
    336339 
    337340                        seldata->SetData(type, data, dataLength); 

  • Mulberry/trunk/Linux/Sources/Application/Server/CServerTable.cp

    r21 r107  
    740740                if (data) 
    741741                { 
    742                         int* i = reinterpret_cast<int*>(data); 
    743                         *i = count; 
    744                         i++; 
    745                         void** vdata = reinterpret_cast<void**>(i); 
     742                        unsigned char* ptr = data; 
     743                        *((int*) ptr) = count; 
     744                        ptr += sizeof(int); 
     745                        void** vdata = reinterpret_cast<void**>(ptr); 
    746746                        for(ulvector::const_iterator iter = rows.begin(); iter != rows.end(); iter++) 
    747747                        { 
    … …  
    13251325                } 
    13261326 
    1327                 //int count = *((int*) drag_data)++; 
    13281327                int count = *((int*)drag_data); 
    13291328                drag_data += sizeof(int); 
    … …  
    13571356        else if (theFlavor == CMulberryApp::sFlavorWDList) 
    13581357        { 
    1359                 //int count = *((int*) drag_data)++; 
    13601358                int count = *(int*)(drag_data); 
    13611359                drag_data += sizeof(int); 
    … …  
    14011399        else if (theFlavor == CMulberryApp::sFlavorMboxList) 
    14021400        { 
    1403                 //int count = *((int*) drag_data)++; 
    14041401                int count = *(int*)drag_data; 
    14051402                drag_data += sizeof(int);