← Back to branch summary

~ubuntu-branches/ubuntu/edgy/pilot-link/edgy

« back to all changes in this revision

Viewing changes to libpisync/sync.c

  • Committer: Bazaar Package Importer
  • Author(s): Ludovic Rousseau
  • Date: 2006-09-22 11:51:36 UTC
  • mfrom: (3.1.8 edgy)
  • Revision ID: james.westby@ubuntu.com-20060922115136-qqmy17bx8j5x0y72
Tags: 0.12.1-5
* urgency medium since libpisock-dev was not usable to build any package
* libpisock-dev now depends on libusb-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
libpisync/sync.c
20
20
 *
21
21
 * You should have received a copy of the GNU Library General Public License
22
22
 * along with this library; if not, write to the Free Software Foundation,
23
 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
23
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
24
24
 */
25
25
 
26
26
#include <stdlib.h>
298
298
{
299
299
        int     result = 0;
300
300
        PilotRecord precord;
301
 
        recordid_t id;
 
301
        recordid_t id_;
302
302
 
303
303
        memset(&precord, 0, sizeof(PilotRecord));
304
304
 
308
308
 
309
309
        PilotCheck(dlp_WriteRecord(sh->sd, dbhandle, precord.flags & dlpRecAttrSecret,
310
310
                                   precord.recID, precord.catID,
311
 
                                   precord.buffer, precord.len, &id));
 
311
                                   precord.buffer, precord.len, &id_));
312
312
 
313
 
        DesktopCheck(sh->SetPilotID(sh, drecord, id));
 
313
        DesktopCheck(sh->SetPilotID(sh, drecord, id_));
314
314
 
315
315
        return result;
316
316
}
579
579
                i,      
580
580
                slow    = 0,
581
581
                result  = 0;
 
582
        pi_buffer_t *recbuf;
582
583
 
583
584
        DesktopRecord *drecord = NULL;
584
585
        PilotRecord *precord = sync_NewPilotRecord(DLP_BUF_SIZE);
598
599
        }
599
600
 
600
601
        i = 0;
601
 
        while (dlp_ReadRecordByIndex
602
 
               (sh->sd, dbhandle, i, precord->buffer, &precord->recID,
603
 
                &precord->len, &precord->flags, &precord->catID) > 0) {
 
602
        recbuf = pi_buffer_new(DLP_BUF_SIZE);
 
603
        while (dlp_ReadRecordByIndex(sh->sd, dbhandle, i, recbuf, &precord->recID,
 
604
                   &precord->flags, &precord->catID) > 0) {
 
605
                precord->len = recbuf->used;
 
606
                if (precord->len > DLP_BUF_SIZE)
 
607
                        precord->len = DLP_BUF_SIZE;
 
608
                memcpy(precord->buffer, recbuf->data, precord->len);
604
609
                result = sh->AddRecord(sh, precord);
605
 
                if (result < 0)
 
610
                if (result < 0) {
 
611
                        pi_buffer_free(recbuf);
606
612
                        goto cleanup;
 
613
                }
607
614
 
608
615
                i++;
609
616
        }
 
617
        pi_buffer_free (recbuf);
610
618
 
611
619
        result = sh->Post(sh, dbhandle);
612
620
 
613
 
      cleanup:
 
621
cleanup:
614
622
        close_db(sh, dbhandle);
615
 
 
 
623
        sync_FreePilotRecord (precord);
616
624
        return result;
617
625
}
618
626
 
670
678
        PilotRecord *precord    = sync_NewPilotRecord(DLP_BUF_SIZE);
671
679
        DesktopRecord *drecord  = NULL;
672
680
        RecordQueue rq          = { 0, NULL };
673
 
 
674
 
        while (dlp_ReadNextModifiedRec(sh->sd, dbhandle, precord->buffer,
 
681
        pi_buffer_t *recbuf = pi_buffer_new(DLP_BUF_SIZE);
 
682
        
 
683
        while (dlp_ReadNextModifiedRec(sh->sd, dbhandle, recbuf,
675
684
                                       &precord->recID, NULL,
676
 
                                       &precord->len, &precord->flags,
 
685
                                       &precord->flags,
677
686
                                       &precord->catID) >= 0) {
678
687
                int count = rq.count;
679
 
 
 
688
                precord->len = recbuf->used;
 
689
                if (precord->len > DLP_BUF_SIZE)
 
690
                        precord->len = DLP_BUF_SIZE;
 
691
                memcpy(precord->buffer, recbuf->data, precord->len);
680
692
                ErrorCheck(sh->Match(sh, precord, &drecord));
681
693
                ErrorCheck(sync_record
682
694
                           (sh, dbhandle, drecord, precord, &rq, rec_mod));
684
696
                if (drecord && rq.count == count)
685
697
                        ErrorCheck(sh->FreeMatch(sh, drecord));
686
698
        }
 
699
        pi_buffer_free(recbuf);
687
700
        sync_FreePilotRecord(precord);
688
701
 
689
702
        result = sync_MergeFromPilot_process(sh, dbhandle, &rq, rec_mod);
710
723
                parch, 
711
724
                psecret,
712
725
                result = 0;
 
726
        pi_buffer_t *recbuf;
713
727
 
714
728
        PilotRecord *precord    = sync_NewPilotRecord(DLP_BUF_SIZE);
715
729
        DesktopRecord *drecord  = NULL;
716
730
        RecordQueue rq          = { 0, NULL };
717
731
 
718
732
        i = 0;
 
733
        recbuf = pi_buffer_new(DLP_BUF_SIZE);
719
734
        while (dlp_ReadRecordByIndex
720
 
               (sh->sd, dbhandle, i, precord->buffer, &precord->recID,
721
 
                &precord->len, &precord->flags, &precord->catID) > 0) {
 
735
               (sh->sd, dbhandle, i, recbuf, &precord->recID,
 
736
                        &precord->flags, &precord->catID) > 0) {
722
737
                int     count = rq.count;
723
738
 
 
739
                precord->len = recbuf->used;
 
740
                if (precord->len > DLP_BUF_SIZE)
 
741
                        precord->len = DLP_BUF_SIZE;
 
742
                memcpy(precord->buffer, recbuf->data, precord->len);
 
743
                
724
744
                ErrorCheck(sh->Match(sh, precord, &drecord));
725
745
 
726
746
                /* Since this is a slow sync, we must calculate the flags */
753
773
 
754
774
                i++;
755
775
        }
 
776
        pi_buffer_free(recbuf);
 
777
 
756
778
        sync_FreePilotRecord(precord);
757
779
 
758
780
        result = sync_MergeFromPilot_process(sh, dbhandle, &rq, rec_mod);
823
845
        PilotRecord *precord    = NULL;
824
846
        DesktopRecord *drecord  = NULL;
825
847
        RecordQueue rq          = { 0, NULL };
 
848
        pi_buffer_t *recbuf = pi_buffer_new(DLP_BUF_SIZE);
826
849
 
827
850
        while (sh->ForEachModified(sh, &drecord) == 0 && drecord) {
828
851
                if (drecord->recID != 0) {
830
853
                        precord->recID = drecord->recID;
831
854
                        PilotCheck(dlp_ReadRecordById(sh->sd, dbhandle,
832
855
                                                      precord->recID,
833
 
                                                      precord->buffer,
834
 
                                                      NULL, &precord->len,
 
856
                                                      recbuf,
 
857
                                                      NULL,
835
858
                                                      &precord->flags,
836
859
                                                      &precord->catID));
 
860
                        precord->len = recbuf->used;
 
861
                        if (precord->len > DLP_BUF_SIZE)
 
862
                                precord->len = DLP_BUF_SIZE;
 
863
                        memcpy(precord->buffer, recbuf->data, precord->len);
837
864
                }
838
865
 
839
866
                ErrorCheck(sync_record
843
870
                        sync_FreePilotRecord (precord);
844
871
                precord = NULL;
845
872
        }
 
873
        pi_buffer_free(recbuf);
846
874
 
847
875
        result = sync_MergeFromPilot_process(sh, dbhandle, &rq, rec_mod);
848
876
 
870
898
        PilotRecord *precord    = NULL;
871
899
        DesktopRecord *drecord  = NULL;
872
900
        RecordQueue rq          = { 0, NULL };
873
 
 
 
901
        pi_buffer_t *recbuf = pi_buffer_new(DLP_BUF_SIZE);
874
902
 
875
903
        while (sh->ForEach(sh, &drecord) == 0 && drecord) {
876
904
                if (drecord->recID != 0) {
878
906
                        precord->recID = drecord->recID;
879
907
                        PilotCheck(dlp_ReadRecordById(sh->sd, dbhandle,
880
908
                                                      precord->recID,
881
 
                                                      precord->buffer,
882
 
                                                      NULL, &precord->len,
 
909
                                                      recbuf,
 
910
                                                      NULL,
883
911
                                                      &precord->flags,
884
912
                                                      &precord->catID));
 
913
                        precord->len = recbuf->used;
 
914
                        if (precord->len > DLP_BUF_SIZE)
 
915
                                precord->len = DLP_BUF_SIZE;
 
916
                        memcpy(precord->buffer, recbuf->data, precord->len);
885
917
                }
886
918
 
887
919
                /* Since this is a slow sync, we must calculate the flags */
913
945
                        sync_FreePilotRecord (precord);
914
946
                precord = NULL;
915
947
        }
 
948
        pi_buffer_free(recbuf);
916
949
 
917
950
        result = sync_MergeFromPilot_process(sh, dbhandle, &rq, rec_mod);
918
951