← Back to branch summary

~ubuntu-branches/ubuntu/maverick/evolution-data-server/maverick-proposed

« back to all changes in this revision

Viewing changes to addressbook/backends/ldap/openldap-extract.h

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-05-17 17:02:06 UTC
  • mfrom: (1.1.79 upstream) (1.6.12 experimental)
  • Revision ID: james.westby@ubuntu.com-20100517170206-4ufr52vwrhh26yh0
Tags: 2.30.1-1ubuntu1
https://launchpad.net/bugs/42199
https://launchpad.net/bugs/229669
https://launchpad.net/bugs/173703
https://launchpad.net/bugs/360344
https://launchpad.net/bugs/508494
* Merge from debian experimental. Remaining change:
  (LP: #42199, #229669, #173703, #360344, #508494)
  + debian/control:
    - add Vcs-Bzr tag
    - don't use libgnome
    - Use Breaks instead of Conflicts against evolution 2.25 and earlier.
  + debian/evolution-data-server.install,
    debian/patches/45_libcamel_providers_version.patch:
    - use the upstream versioning, not a Debian-specific one 
  + debian/libedata-book1.2-dev.install, debian/libebackend-1.2-dev.install,
    debian/libcamel1.2-dev.install, debian/libedataserverui1.2-dev.install:
    - install html documentation
  + debian/rules:
    - don't build documentation it's shipped with the tarball

Show diffs side-by-side

added added

removed removed

Lines of Context:
addressbook/backends/ldap/openldap-extract.h
82
82
#ifndef LDAP_INSUFFICIENT_ACCESS
83
83
#define LDAP_INSUFFICIENT_ACCESS 0x32
84
84
#endif
85
 
 
 
85
 
86
86
#endif
87
87
 
88
88
#define LDAP_SCHERR_OUTOFMEM            1
204
204
                kind = TK_QDSTRING;
205
205
                (*sp)++;
206
206
                p = *sp;
207
 
                while ( **sp != '\'' && **sp != '\0' )
 
207
                while (**sp != '\'' && **sp != '\0')
208
208
                        (*sp)++;
209
 
                if ( **sp == '\'' ) {
 
209
                if (**sp == '\'') {
210
210
                        q = *sp;
211
211
                        res = LDAP_MALLOC(q-p+1);
212
 
                        if ( !res ) {
 
212
                        if (!res) {
213
213
                                kind = TK_OUTOFMEM;
214
214
                        } else {
215
215
                                strncpy(res,p,q-p);
233
233
                        (*sp)++;
234
234
                q = *sp;
235
235
                res = LDAP_MALLOC(q-p+1);
236
 
                if ( !res ) {
 
236
                if (!res) {
237
237
                        kind = TK_OUTOFMEM;
238
238
                } else {
239
239
                        strncpy(res,p,q-p);
266
266
        gint quoted = 0;
267
267
 
268
268
        /* Netscape puts the SYNTAX value in quotes (incorrectly) */
269
 
        if ( flags & LDAP_SCHEMA_ALLOW_QUOTED && **sp == '\'' ) {
 
269
        if (flags & LDAP_SCHEMA_ALLOW_QUOTED && **sp == '\'') {
270
270
                quoted = 1;
271
271
                (*sp)++;
272
272
                start++;
273
273
        }
274
274
        /* Each iteration of this loop gets one decimal string */
275
275
        while (**sp) {
276
 
                if ( !LDAP_DIGIT(**sp) ) {
 
276
                if (!LDAP_DIGIT(**sp)) {
277
277
                        /*
278
278
                         * Initial gchar is not a digit or gchar after dot is
279
279
                         * not a digit
282
282
                        return NULL;
283
283
                }
284
284
                (*sp)++;
285
 
                while ( LDAP_DIGIT(**sp) )
 
285
                while (LDAP_DIGIT(**sp))
286
286
                        (*sp)++;
287
 
                if ( **sp != '.' )
 
287
                if (**sp != '.')
288
288
                        break;
289
289
                /* Otherwise, gobble the dot and loop again */
290
290
                (*sp)++;
291
291
        }
292
292
        /* Now *sp points at the gchar past the numericoid. Perfect. */
293
293
        len = *sp - start;
294
 
        if ( flags & LDAP_SCHEMA_ALLOW_QUOTED && quoted ) {
295
 
                if ( **sp == '\'' ) {
 
294
        if (flags & LDAP_SCHEMA_ALLOW_QUOTED && quoted) {
 
295
                if (**sp == '\'') {
296
296
                        (*sp)++;
297
297
                } else {
298
298
                        *code = LDAP_SCHERR_UNEXPTOKEN;
326
326
 
327
327
        parse_whsp(sp);
328
328
        kind = get_token(sp,&sval);
329
 
        if ( kind == TK_LEFTPAREN ) {
 
329
        if (kind == TK_LEFTPAREN) {
330
330
                /* Let's presume there will be at least 2 entries */
331
331
                size = 3;
332
332
                res = LDAP_CALLOC(3,sizeof(gchar *));
333
 
                if ( !res ) {
 
333
                if (!res) {
334
334
                        *code = LDAP_SCHERR_OUTOFMEM;
335
335
                        return NULL;
336
336
                }
338
338
                while (1) {
339
339
                        parse_whsp(sp);
340
340
                        kind = get_token(sp,&sval);
341
 
                        if ( kind == TK_RIGHTPAREN )
 
341
                        if (kind == TK_RIGHTPAREN)
342
342
                                break;
343
 
                        if ( kind == TK_QDESCR ) {
344
 
                                if ( pos == size-2 ) {
 
343
                        if (kind == TK_QDESCR) {
 
344
                                if (pos == size-2) {
345
345
                                        size++;
346
346
                                        res1 = LDAP_REALLOC(res,size*sizeof(gchar *));
347
 
                                        if ( !res1 ) {
 
347
                                        if (!res1) {
348
348
                                                LDAP_VFREE(res);
349
349
                                                LDAP_FREE(sval);
350
350
                                                *code = LDAP_SCHERR_OUTOFMEM;
364
364
                }
365
365
                parse_whsp(sp);
366
366
                return(res);
367
 
        } else if ( kind == TK_QDESCR ) {
 
367
        } else if (kind == TK_QDESCR) {
368
368
                res = LDAP_CALLOC(2,sizeof(gchar *));
369
 
                if ( !res ) {
 
369
                if (!res) {
370
370
                        *code = LDAP_SCHERR_OUTOFMEM;
371
371
                        return NULL;
372
372
                }
400
400
         */
401
401
        parse_whsp(sp);
402
402
        kind = get_token(sp,&sval);
403
 
        if ( kind == TK_LEFTPAREN ) {
 
403
        if (kind == TK_LEFTPAREN) {
404
404
                /* Let's presume there will be at least 2 entries */
405
405
                size = 3;
406
406
                res = LDAP_CALLOC(3,sizeof(gchar *));
407
 
                if ( !res ) {
 
407
                if (!res) {
408
408
                        *code = LDAP_SCHERR_OUTOFMEM;
409
409
                        return NULL;
410
410
                }
424
424
                parse_whsp(sp);
425
425
                while (1) {
426
426
                        kind = get_token(sp,&sval);
427
 
                        if ( kind == TK_RIGHTPAREN )
 
427
                        if (kind == TK_RIGHTPAREN)
428
428
                                break;
429
 
                        if ( kind == TK_DOLLAR ) {
 
429
                        if (kind == TK_DOLLAR) {
430
430
                                parse_whsp(sp);
431
431
                                kind = get_token(sp,&sval);
432
432
                                if ( kind == TK_BAREWORD ||
433
433
                                     ( allow_quoted &&
434
434
                                       kind == TK_QDSTRING ) ) {
435
 
                                        if ( pos == size-2 ) {
 
435
                                        if (pos == size-2) {
436
436
                                                size++;
437
437
                                                res1 = LDAP_REALLOC(res,size*sizeof(gchar *));
438
 
                                                if ( !res1 ) {
 
438
                                                if (!res1) {
439
439
                                                        LDAP_FREE(sval);
440
440
                                                        LDAP_VFREE(res);
441
441
                                                        *code = LDAP_SCHERR_OUTOFMEM;
464
464
        } else if ( kind == TK_BAREWORD ||
465
465
                    ( allow_quoted && kind == TK_QDSTRING ) ) {
466
466
                res = LDAP_CALLOC(2,sizeof(gchar *));
467
 
                if ( !res ) {
 
467
                if (!res) {
468
468
                        LDAP_FREE(sval);
469
469
                        *code = LDAP_SCHERR_OUTOFMEM;
470
470
                        return NULL;
512
512
        gchar ** ext_vals;
513
513
        const gchar * savepos;
514
514
 
515
 
        if ( !s ) {
 
515
        if (!s) {
516
516
                *code = LDAP_SCHERR_EMPTY;
517
517
                *errp = "";
518
518
                return NULL;
521
521
        *errp = s;
522
522
        oc = LDAP_CALLOC(1,sizeof(LDAPObjectClass));
523
523
 
524
 
        if ( !oc ) {
 
524
        if (!oc) {
525
525
                *code = LDAP_SCHERR_OUTOFMEM;
526
526
                return NULL;
527
527
        }
528
528
        oc->oc_kind = LDAP_SCHEMA_STRUCTURAL;
529
529
 
530
530
        kind = get_token(&ss,&sval);
531
 
        if ( kind != TK_LEFTPAREN ) {
 
531
        if (kind != TK_LEFTPAREN) {
532
532
                *code = LDAP_SCHERR_NOLEFTPAREN;
533
533
                LDAP_FREE(sval);
534
534
                ldap_objectclass_free(oc);
545
545
        parse_whsp(&ss);
546
546
        savepos = ss;
547
547
        oc->oc_oid = ldap_int_parse_numericoid(&ss,code,0);
548
 
        if ( !oc->oc_oid ) {
549
 
                if ( (flags & LDAP_SCHEMA_ALLOW_ALL) && (ss == savepos) ) {
 
548
        if (!oc->oc_oid) {
 
549
                if ((flags & LDAP_SCHEMA_ALLOW_ALL) && (ss == savepos)) {
550
550
                        /* Backtracking */
551
551
                        ss = savepos;
552
552
                        kind = get_token(&ss,&sval);
553
 
                        if ( kind == TK_BAREWORD ) {
 
553
                        if (kind == TK_BAREWORD) {
554
554
                                if ( !strcasecmp(sval, "NAME") ||
555
555
                                     !strcasecmp(sval, "DESC") ||
556
556
                                     !strcasecmp(sval, "OBSOLETE") ||
596
596
                case TK_RIGHTPAREN:
597
597
                        return oc;
598
598
                case TK_BAREWORD:
599
 
                        if ( !strcasecmp(sval,"NAME") ) {
 
599
                        if (!strcasecmp(sval,"NAME")) {
600
600
                                LDAP_FREE(sval);
601
 
                                if ( seen_name ) {
 
601
                                if (seen_name) {
602
602
                                        *code = LDAP_SCHERR_DUPOPT;
603
603
                                        *errp = ss;
604
604
                                        ldap_objectclass_free(oc);
606
606
                                }
607
607
                                seen_name = 1;
608
608
                                oc->oc_names = parse_qdescrs(&ss,code);
609
 
                                if ( !oc->oc_names ) {
610
 
                                        if ( *code != LDAP_SCHERR_OUTOFMEM )
 
609
                                if (!oc->oc_names) {
 
610
                                        if (*code != LDAP_SCHERR_OUTOFMEM)
611
611
                                                *code = LDAP_SCHERR_BADNAME;
612
612
                                        *errp = ss;
613
613
                                        ldap_objectclass_free(oc);
614
614
                                        return NULL;
615
615
                                }
616
 
                        } else if ( !strcasecmp(sval,"DESC") ) {
 
616
                        } else if (!strcasecmp(sval,"DESC")) {
617
617
                                LDAP_FREE(sval);
618
 
                                if ( seen_desc ) {
 
618
                                if (seen_desc) {
619
619
                                        *code = LDAP_SCHERR_DUPOPT;
620
620
                                        *errp = ss;
621
621
                                        ldap_objectclass_free(oc);
624
624
                                seen_desc = 1;
625
625
                                parse_whsp(&ss);
626
626
                                kind = get_token(&ss,&sval);
627
 
                                if ( kind != TK_QDSTRING ) {
 
627
                                if (kind != TK_QDSTRING) {
628
628
                                        *code = LDAP_SCHERR_UNEXPTOKEN;
629
629
                                        *errp = ss;
630
630
                                        LDAP_FREE(sval);
633
633
                                }
634
634
                                oc->oc_desc = sval;
635
635
                                parse_whsp(&ss);
636
 
                        } else if ( !strcasecmp(sval,"OBSOLETE") ) {
 
636
                        } else if (!strcasecmp(sval,"OBSOLETE")) {
637
637
                                LDAP_FREE(sval);
638
 
                                if ( seen_obsolete ) {
 
638
                                if (seen_obsolete) {
639
639
                                        *code = LDAP_SCHERR_DUPOPT;
640
640
                                        *errp = ss;
641
641
                                        ldap_objectclass_free(oc);
644
644
                                seen_obsolete = 1;
645
645
                                oc->oc_obsolete = LDAP_SCHEMA_YES;
646
646
                                parse_whsp(&ss);
647
 
                        } else if ( !strcasecmp(sval,"SUP") ) {
 
647
                        } else if (!strcasecmp(sval,"SUP")) {
648
648
                                LDAP_FREE(sval);
649
 
                                if ( seen_sup ) {
 
649
                                if (seen_sup) {
650
650
                                        *code = LDAP_SCHERR_DUPOPT;
651
651
                                        *errp = ss;
652
652
                                        ldap_objectclass_free(oc);
656
656
                                oc->oc_sup_oids = parse_oids(&ss,
657
657
                                                             code,
658
658
                                                             flags);
659
 
                                if ( !oc->oc_sup_oids ) {
 
659
                                if (!oc->oc_sup_oids) {
660
660
                                        *errp = ss;
661
661
                                        ldap_objectclass_free(oc);
662
662
                                        return NULL;
663
663
                                }
664
 
                        } else if ( !strcasecmp(sval,"ABSTRACT") ) {
 
664
                        } else if (!strcasecmp(sval,"ABSTRACT")) {
665
665
                                LDAP_FREE(sval);
666
 
                                if ( seen_kind ) {
 
666
                                if (seen_kind) {
667
667
                                        *code = LDAP_SCHERR_DUPOPT;
668
668
                                        *errp = ss;
669
669
                                        ldap_objectclass_free(oc);
672
672
                                seen_kind = 1;
673
673
                                oc->oc_kind = LDAP_SCHEMA_ABSTRACT;
674
674
                                parse_whsp(&ss);
675
 
                        } else if ( !strcasecmp(sval,"STRUCTURAL") ) {
 
675
                        } else if (!strcasecmp(sval,"STRUCTURAL")) {
676
676
                                LDAP_FREE(sval);
677
 
                                if ( seen_kind ) {
 
677
                                if (seen_kind) {
678
678
                                        *code = LDAP_SCHERR_DUPOPT;
679
679
                                        *errp = ss;
680
680
                                        ldap_objectclass_free(oc);
683
683
                                seen_kind = 1;
684
684
                                oc->oc_kind = LDAP_SCHEMA_STRUCTURAL;
685
685
                                parse_whsp(&ss);
686
 
                        } else if ( !strcasecmp(sval,"AUXILIARY") ) {
 
686
                        } else if (!strcasecmp(sval,"AUXILIARY")) {
687
687
                                LDAP_FREE(sval);
688
 
                                if ( seen_kind ) {
 
688
                                if (seen_kind) {
689
689
                                        *code = LDAP_SCHERR_DUPOPT;
690
690
                                        *errp = ss;
691
691
                                        ldap_objectclass_free(oc);
694
694
                                seen_kind = 1;
695
695
                                oc->oc_kind = LDAP_SCHEMA_AUXILIARY;
696
696
                                parse_whsp(&ss);
697
 
                        } else if ( !strcasecmp(sval,"MUST") ) {
 
697
                        } else if (!strcasecmp(sval,"MUST")) {
698
698
                                LDAP_FREE(sval);
699
 
                                if ( seen_must ) {
 
699
                                if (seen_must) {
700
700
                                        *code = LDAP_SCHERR_DUPOPT;
701
701
                                        *errp = ss;
702
702
                                        ldap_objectclass_free(oc);
704
704
                                }
705
705
                                seen_must = 1;
706
706
                                oc->oc_at_oids_must = parse_oids(&ss,code,0);
707
 
                                if ( !oc->oc_at_oids_must ) {
 
707
                                if (!oc->oc_at_oids_must) {
708
708
                                        *errp = ss;
709
709
                                        ldap_objectclass_free(oc);
710
710
                                        return NULL;
711
711
                                }
712
712
                                parse_whsp(&ss);
713
 
                        } else if ( !strcasecmp(sval,"MAY") ) {
 
713
                        } else if (!strcasecmp(sval,"MAY")) {
714
714
                                LDAP_FREE(sval);
715
 
                                if ( seen_may ) {
 
715
                                if (seen_may) {
716
716
                                        *code = LDAP_SCHERR_DUPOPT;
717
717
                                        *errp = ss;
718
718
                                        ldap_objectclass_free(oc);
720
720
                                }
721
721
                                seen_may = 1;
722
722
                                oc->oc_at_oids_may = parse_oids(&ss,code,0);
723
 
                                if ( !oc->oc_at_oids_may ) {
 
723
                                if (!oc->oc_at_oids_may) {
724
724
                                        *errp = ss;
725
725
                                        ldap_objectclass_free(oc);
726
726
                                        return NULL;
727
727
                                }
728
728
                                parse_whsp(&ss);
729
 
                        } else if ( sval[0] == 'X' && sval[1] == '-' ) {
 
729
                        } else if (sval[0] == 'X' && sval[1] == '-') {
730
730
                                /* Should be parse_qdstrings */
731
731
                                ext_vals = parse_qdescrs(&ss, code);
732
 
                                if ( !ext_vals ) {
 
732
                                if (!ext_vals) {
733
733
                                        *errp = ss;
734
734
                                        ldap_objectclass_free(oc);
735
735
                                        return NULL;
772
772
static gchar *ldap_utf8_strchr( const gchar *str, const gchar *chr )
773
773
{
774
774
        for (; *str != '\0'; LDAP_UTF8_INCR(str) ) {
775
 
                if ( ldap_x_utf8_to_ucs4( str ) == ldap_x_utf8_to_ucs4( chr ) ) {
 
775
                if (ldap_x_utf8_to_ucs4( str ) == ldap_x_utf8_to_ucs4( chr )) {
776
776
                        return (gchar *) str;
777
777
                }
778
778
        }
787
787
 
788
788
        for ( cstr = str; *cstr != '\0'; LDAP_UTF8_INCR(cstr) ) {
789
789
                for ( cset = set; *cset != '\0'; LDAP_UTF8_INCR(cset) ) {
790
 
                        if ( ldap_x_utf8_to_ucs4( cstr ) == ldap_x_utf8_to_ucs4( cset ) ) {
 
790
                        if (ldap_x_utf8_to_ucs4( cstr ) == ldap_x_utf8_to_ucs4( cset )) {
791
791
                                return cstr - str;
792
792
                        }
793
793
                }
803
803
 
804
804
        for ( cstr = str; *cstr != '\0'; LDAP_UTF8_INCR(cstr) ) {
805
805
                for ( cset = set; ; LDAP_UTF8_INCR(cset) ) {
806
 
                        if ( *cset == '\0' ) {
 
806
                        if (*cset == '\0') {
807
807
                                return cstr - str;
808
808
                        }
809
809
 
810
 
                        if ( ldap_x_utf8_to_ucs4( cstr ) == ldap_x_utf8_to_ucs4( cset ) ) {
 
810
                        if (ldap_x_utf8_to_ucs4( cstr ) == ldap_x_utf8_to_ucs4( cset )) {
811
811
                                break;
812
812
                        }
813
813
                }
821
821
        gchar *begin;
822
822
        gchar *end;
823
823
 
824
 
        if ( last == NULL ) return NULL;
 
824
        if (last == NULL) return NULL;
825
825
 
826
826
        begin = str ? str : *last;
827
827
 
828
828
        begin += ldap_utf8_strspn( begin, sep );
829
829
 
830
 
        if ( *begin == '\0' ) {
 
830
        if (*begin == '\0') {
831
831
                *last = NULL;
832
832
                return NULL;
833
833
        }
834
834
 
835
835
        end = &begin[ ldap_utf8_strcspn( begin, sep ) ];
836
836
 
837
 
        if ( *end != '\0' ) {
 
837
        if (*end != '\0') {
838
838
                gchar *next = LDAP_UTF8_NEXT( end );
839
839
                *end = '\0';
840
840
                end = next;
896
896
         */
897
897
        const gchar *p;
898
898
 
899
 
        if ( url == NULL ) {
 
899
        if (url == NULL) {
900
900
                return( NULL );
901
901
        }
902
902
 
903
903
        p = url;
904
904
 
905
905
        /* skip leading '<' (if any) */
906
 
        if ( *p == '<' ) {
 
906
        if (*p == '<') {
907
907
                *enclosedp = 1;
908
908
                ++p;
909
909
        } else {
911
911
        }
912
912
 
913
913
        /* skip leading "URL:" (if any) */
914
 
        if ( strncasecmp( p, LDAP_URL_URLCOLON, LDAP_URL_URLCOLON_LEN ) == 0 ) {
 
914
        if (strncasecmp( p, LDAP_URL_URLCOLON, LDAP_URL_URLCOLON_LEN ) == 0) {
915
915
                p += LDAP_URL_URLCOLON_LEN;
916
916
        }
917
917
 
918
918
        /* check for "ldap://" prefix */
919
 
        if ( strncasecmp( p, LDAP_URL_PREFIX, LDAP_URL_PREFIX_LEN ) == 0 ) {
 
919
        if (strncasecmp( p, LDAP_URL_PREFIX, LDAP_URL_PREFIX_LEN ) == 0) {
920
920
                /* skip over "ldap://" prefix and return success */
921
921
                p += LDAP_URL_PREFIX_LEN;
922
922
                *scheme = "ldap";
924
924
        }
925
925
 
926
926
        /* check for "ldaps://" prefix */
927
 
        if ( strncasecmp( p, LDAPS_URL_PREFIX, LDAPS_URL_PREFIX_LEN ) == 0 ) {
 
927
        if (strncasecmp( p, LDAPS_URL_PREFIX, LDAPS_URL_PREFIX_LEN ) == 0) {
928
928
                /* skip over "ldaps://" prefix and return success */
929
929
                p += LDAPS_URL_PREFIX_LEN;
930
930
                *scheme = "ldaps";
932
932
        }
933
933
 
934
934
        /* check for "ldapi://" prefix */
935
 
        if ( strncasecmp( p, LDAPI_URL_PREFIX, LDAPI_URL_PREFIX_LEN ) == 0 ) {
 
935
        if (strncasecmp( p, LDAPI_URL_PREFIX, LDAPI_URL_PREFIX_LEN ) == 0) {
936
936
                /* skip over "ldapi://" prefix and return success */
937
937
                p += LDAPI_URL_PREFIX_LEN;
938
938
                *scheme = "ldapi";
941
941
 
942
942
#ifdef LDAP_CONNECTIONLESS
943
943
        /* check for "cldap://" prefix */
944
 
        if ( strncasecmp( p, LDAPC_URL_PREFIX, LDAPC_URL_PREFIX_LEN ) == 0 ) {
 
944
        if (strncasecmp( p, LDAPC_URL_PREFIX, LDAPC_URL_PREFIX_LEN ) == 0) {
945
945
                /* skip over "cldap://" prefix and return success */
946
946
                p += LDAPC_URL_PREFIX_LEN;
947
947
                *scheme = "cldap";
954
954
 
955
955
static gint str2scope( const gchar *p )
956
956
{
957
 
        if ( strcasecmp( p, "one" ) == 0 ) {
958
 
                return LDAP_SCOPE_ONELEVEL;
959
 
 
960
 
        } else if ( strcasecmp( p, "onelevel" ) == 0 ) {
961
 
                return LDAP_SCOPE_ONELEVEL;
962
 
 
963
 
        } else if ( strcasecmp( p, "base" ) == 0 ) {
 
957
        if (strcasecmp( p, "one" ) == 0) {
 
958
                return LDAP_SCOPE_ONELEVEL;
 
959
 
 
960
        } else if (strcasecmp( p, "onelevel" ) == 0) {
 
961
                return LDAP_SCOPE_ONELEVEL;
 
962
 
 
963
        } else if (strcasecmp( p, "base" ) == 0) {
964
964
                return LDAP_SCOPE_BASE;
965
965
 
966
 
        } else if ( strcasecmp( p, "sub" ) == 0 ) {
 
966
        } else if (strcasecmp( p, "sub" ) == 0) {
967
967
                return LDAP_SCOPE_SUBTREE;
968
968
 
969
 
        } else if ( strcasecmp( p, "subtree" ) == 0 ) {
 
969
        } else if (strcasecmp( p, "subtree" ) == 0) {
970
970
                return LDAP_SCOPE_SUBTREE;
971
971
        }
972
972
 
976
976
static void
977
977
ldap_free_urldesc( LDAPURLDesc *ludp )
978
978
{
979
 
        if ( ludp == NULL ) {
 
979
        if (ludp == NULL) {
980
980
                return;
981
981
        }
982
982
 
983
 
        if ( ludp->lud_scheme != NULL ) {
 
983
        if (ludp->lud_scheme != NULL) {
984
984
                LDAP_FREE( ludp->lud_scheme );
985
985
        }
986
986
 
987
 
        if ( ludp->lud_host != NULL ) {
 
987
        if (ludp->lud_host != NULL) {
988
988
                LDAP_FREE( ludp->lud_host );
989
989
        }
990
990
 
991
 
        if ( ludp->lud_dn != NULL ) {
 
991
        if (ludp->lud_dn != NULL) {
992
992
                LDAP_FREE( ludp->lud_dn );
993
993
        }
994
994
 
995
 
        if ( ludp->lud_filter != NULL ) {
 
995
        if (ludp->lud_filter != NULL) {
996
996
                LDAP_FREE( ludp->lud_filter);
997
997
        }
998
998
 
999
 
        if ( ludp->lud_attrs != NULL ) {
 
999
        if (ludp->lud_attrs != NULL) {
1000
1000
                LDAP_VFREE( ludp->lud_attrs );
1001
1001
        }
1002
1002
 
1003
 
        if ( ludp->lud_exts != NULL ) {
 
1003
        if (ludp->lud_exts != NULL) {
1004
1004
                LDAP_VFREE( ludp->lud_exts );
1005
1005
        }
1006
1006
 
1025
1025
        gchar   *p;
1026
1026
 
1027
1027
        for ( p = s; *s != '\0'; ++s ) {
1028
 
                if ( *s == '%' ) {
1029
 
                        if ( *++s == '\0' ) {
 
1028
                if (*s == '%') {
 
1029
                        if (*++s == '\0') {
1030
1030
                                break;
1031
1031
                        }
1032
1032
                        *p = ldap_int_unhex( *s ) << 4;
1033
 
                        if ( *++s == '\0' ) {
 
1033
                        if (*++s == '\0') {
1034
1034
                                break;
1035
1035
                        }
1036
1036
                        *p++ += ldap_int_unhex( *s );
1052
1052
 
1053
1053
        /* protect the input string from strtok */
1054
1054
        str = LDAP_STRDUP( str_in );
1055
 
        if ( str == NULL ) {
 
1055
        if (str == NULL) {
1056
1056
                return NULL;
1057
1057
        }
1058
1058
 
1059
1059
        i = 1;
1060
1060
        for ( s = str; *s; s++ ) {
1061
 
                if ( ldap_utf8_strchr( brkstr, s ) != NULL ) {
 
1061
                if (ldap_utf8_strchr( brkstr, s ) != NULL) {
1062
1062
                        i++;
1063
1063
                }
1064
1064
        }
1065
1065
 
1066
1066
        res = (gchar **) LDAP_MALLOC( (i + 1) * sizeof(gchar *) );
1067
1067
 
1068
 
        if ( res == NULL ) {
 
1068
        if (res == NULL) {
1069
1069
                LDAP_FREE( str );
1070
1070
                return NULL;
1071
1071
        }
1110
1110
        const gchar *url_tmp;
1111
1111
        gchar *url;
1112
1112
 
1113
 
        if ( url_in == NULL || ludpp == NULL ) {
 
1113
        if (url_in == NULL || ludpp == NULL) {
1114
1114
                return LDAP_URL_ERR_PARAM;
1115
1115
        }
1116
1116
 
1118
1118
 
1119
1119
        url_tmp = skip_url_prefix( url_in, &enclosed, &scheme );
1120
1120
 
1121
 
        if ( url_tmp == NULL ) {
 
1121
        if (url_tmp == NULL) {
1122
1122
                return LDAP_URL_ERR_BADSCHEME;
1123
1123
        }
1124
1124
 
1126
1126
 
1127
1127
        /* make working copy of the remainder of the URL */
1128
1128
        url = LDAP_STRDUP( url_tmp );
1129
 
        if ( url == NULL ) {
 
1129
        if (url == NULL) {
1130
1130
                return LDAP_URL_ERR_MEM;
1131
1131
        }
1132
1132
 
1133
 
        if ( enclosed ) {
 
1133
        if (enclosed) {
1134
1134
                p = &url[strlen(url)-1];
1135
1135
 
1136
 
                if ( *p != '>' ) {
 
1136
                if (*p != '>') {
1137
1137
                        LDAP_FREE( url );
1138
1138
                        return LDAP_URL_ERR_BADENCLOSURE;
1139
1139
                }
1144
1144
        /* allocate return struct */
1145
1145
        ludp = (LDAPURLDesc *)LDAP_CALLOC( 1, sizeof( LDAPURLDesc ));
1146
1146
 
1147
 
        if ( ludp == NULL ) {
 
1147
        if (ludp == NULL) {
1148
1148
                LDAP_FREE( url );
1149
1149
                return LDAP_URL_ERR_MEM;
1150
1150
        }
1161
1161
 
1162
1162
        ludp->lud_scheme = LDAP_STRDUP( scheme );
1163
1163
 
1164
 
        if ( ludp->lud_scheme == NULL ) {
 
1164
        if (ludp->lud_scheme == NULL) {
1165
1165
                LDAP_FREE( url );
1166
1166
                ldap_free_urldesc( ludp );
1167
1167
                return LDAP_URL_ERR_MEM;
1170
1170
        /* scan forward for '/' that marks end of hostport and begin. of dn */
1171
1171
        p = strchr( url, '/' );
1172
1172
 
1173
 
        if ( p != NULL ) {
 
1173
        if (p != NULL) {
1174
1174
                /* terminate hostport; point to start of dn */
1175
1175
                *p++ = '\0';
1176
1176
        }
1177
1177
 
1178
1178
        /* IPv6 syntax with [ip address]:port */
1179
 
        if ( *url == '[' ) {
 
1179
        if (*url == '[') {
1180
1180
                r = strchr( url, ']' );
1181
 
                if ( r == NULL ) {
 
1181
                if (r == NULL) {
1182
1182
                        LDAP_FREE( url );
1183
1183
                        ldap_free_urldesc( ludp );
1184
1184
                        return LDAP_URL_ERR_BADURL;
1189
1189
                q = strchr( url, ':' );
1190
1190
        }
1191
1191
 
1192
 
        if ( q != NULL ) {
 
1192
        if (q != NULL) {
1193
1193
                gchar   *next;
1194
1194
 
1195
1195
                *q++ = '\0';
1196
1196
                ldap_pvt_hex_unescape( q );
1197
1197
 
1198
 
                if ( *q == '\0' ) {
 
1198
                if (*q == '\0') {
1199
1199
                        LDAP_FREE( url );
1200
1200
                        ldap_free_urldesc( ludp );
1201
1201
                        return LDAP_URL_ERR_BADURL;
1202
1202
                }
1203
1203
 
1204
1204
                ludp->lud_port = strtol( q, &next, 10 );
1205
 
                if ( next == NULL || next[0] != '\0' ) {
 
1205
                if (next == NULL || next[0] != '\0') {
1206
1206
                        LDAP_FREE( url );
1207
1207
                        ldap_free_urldesc( ludp );
1208
1208
                        return LDAP_URL_ERR_BADURL;
1214
1214
        /* If [ip address]:port syntax, url is [ip and we skip the [ */
1215
1215
        ludp->lud_host = LDAP_STRDUP( url + ( *url == '[' ) );
1216
1216
 
1217
 
        if ( ludp->lud_host == NULL ) {
 
1217
        if (ludp->lud_host == NULL) {
1218
1218
                LDAP_FREE( url );
1219
1219
                ldap_free_urldesc( ludp );
1220
1220
                return LDAP_URL_ERR_MEM;
1234
1234
                /* ? immediately followed by question */
1235
1235
                if ( *q == '?') {
1236
1236
                        q++;
1237
 
                        if ( *q != '\0' ) {
 
1237
                        if (*q != '\0') {
1238
1238
                                /* parse dn part */
1239
1239
                                ldap_pvt_hex_unescape( q );
1240
1240
                                ludp->lud_dn = LDAP_STRDUP( q );
1242
1242
                                ludp->lud_dn = LDAP_STRDUP( "" );
1243
1243
                        }
1244
1244
 
1245
 
                        if ( ludp->lud_dn == NULL ) {
 
1245
                        if (ludp->lud_dn == NULL) {
1246
1246
                                LDAP_FREE( url );
1247
1247
                                ldap_free_urldesc( ludp );
1248
1248
                                return LDAP_URL_ERR_MEM;
1250
1250
                }
1251
1251
        }
1252
1252
 
1253
 
        if ( p == NULL ) {
 
1253
        if (p == NULL) {
1254
1254
                LDAP_FREE( url );
1255
1255
                *ludpp = ludp;
1256
1256
                return LDAP_URL_SUCCESS;
1259
1259
        /* scan forward for '?' that may marks end of dn */
1260
1260
        q = strchr( p, '?' );
1261
1261
 
1262
 
        if ( q != NULL ) {
 
1262
        if (q != NULL) {
1263
1263
                /* terminate dn part */
1264
1264
                *q++ = '\0';
1265
1265
        }
1266
1266
 
1267
 
        if ( *p != '\0' ) {
 
1267
        if (*p != '\0') {
1268
1268
                /* parse dn part */
1269
1269
                ldap_pvt_hex_unescape( p );
1270
1270
                ludp->lud_dn = LDAP_STRDUP( p );
1272
1272
                ludp->lud_dn = LDAP_STRDUP( "" );
1273
1273
        }
1274
1274
 
1275
 
        if ( ludp->lud_dn == NULL ) {
 
1275
        if (ludp->lud_dn == NULL) {
1276
1276
                LDAP_FREE( url );
1277
1277
                ldap_free_urldesc( ludp );
1278
1278
                return LDAP_URL_ERR_MEM;
1279
1279
        }
1280
1280
 
1281
 
        if ( q == NULL ) {
 
1281
        if (q == NULL) {
1282
1282
                /* no more */
1283
1283
                LDAP_FREE( url );
1284
1284
                *ludpp = ludp;
1289
1289
        p = q;
1290
1290
        q = strchr( p, '?' );
1291
1291
 
1292
 
        if ( q != NULL ) {
 
1292
        if (q != NULL) {
1293
1293
                /* terminate attributes part */
1294
1294
                *q++ = '\0';
1295
1295
        }
1296
1296
 
1297
 
        if ( *p != '\0' ) {
 
1297
        if (*p != '\0') {
1298
1298
                /* parse attributes */
1299
1299
                ldap_pvt_hex_unescape( p );
1300
1300
                ludp->lud_attrs = ldap_str2charray( p, "," );
1301
1301
 
1302
 
                if ( ludp->lud_attrs == NULL ) {
 
1302
                if (ludp->lud_attrs == NULL) {
1303
1303
                        LDAP_FREE( url );
1304
1304
                        ldap_free_urldesc( ludp );
1305
1305
                        return LDAP_URL_ERR_BADATTRS;
1306
1306
                }
1307
1307
        }
1308
1308
 
1309
 
        if ( q == NULL ) {
 
1309
        if (q == NULL) {
1310
1310
                /* no more */
1311
1311
                LDAP_FREE( url );
1312
1312
                *ludpp = ludp;
1317
1317
        p = q;
1318
1318
        q = strchr( p, '?' );
1319
1319
 
1320
 
        if ( q != NULL ) {
 
1320
        if (q != NULL) {
1321
1321
                /* terminate the scope part */
1322
1322
                *q++ = '\0';
1323
1323
        }
1324
1324
 
1325
 
        if ( *p != '\0' ) {
 
1325
        if (*p != '\0') {
1326
1326
                /* parse the scope */
1327
1327
                ldap_pvt_hex_unescape( p );
1328
1328
                ludp->lud_scope = str2scope( p );
1329
1329
 
1330
 
                if ( ludp->lud_scope == -1 ) {
 
1330
                if (ludp->lud_scope == -1) {
1331
1331
                        LDAP_FREE( url );
1332
1332
                        ldap_free_urldesc( ludp );
1333
1333
                        return LDAP_URL_ERR_BADSCOPE;
1334
1334
                }
1335
1335
        }
1336
1336
 
1337
 
        if ( q == NULL ) {
 
1337
        if (q == NULL) {
1338
1338
                /* no more */
1339
1339
                LDAP_FREE( url );
1340
1340
                *ludpp = ludp;
1345
1345
        p = q;
1346
1346
        q = strchr( p, '?' );
1347
1347
 
1348
 
        if ( q != NULL ) {
 
1348
        if (q != NULL) {
1349
1349
                /* terminate the filter part */
1350
1350
                *q++ = '\0';
1351
1351
        }
1352
1352
 
1353
 
        if ( *p != '\0' ) {
 
1353
        if (*p != '\0') {
1354
1354
                /* parse the filter */
1355
1355
                ldap_pvt_hex_unescape( p );
1356
1356
 
1357
 
                if ( ! *p ) {
 
1357
                if (!*p) {
1358
1358
                        /* missing filter */
1359
1359
                        LDAP_FREE( url );
1360
1360
                        ldap_free_urldesc( ludp );
1364
1364
                LDAP_FREE( ludp->lud_filter );
1365
1365
                ludp->lud_filter = LDAP_STRDUP( p );
1366
1366
 
1367
 
                if ( ludp->lud_filter == NULL ) {
 
1367
                if (ludp->lud_filter == NULL) {
1368
1368
                        LDAP_FREE( url );
1369
1369
                        ldap_free_urldesc( ludp );
1370
1370
                        return LDAP_URL_ERR_MEM;
1371
1371
                }
1372
1372
        }
1373
1373
 
1374
 
        if ( q == NULL ) {
 
1374
        if (q == NULL) {
1375
1375
                /* no more */
1376
1376
                LDAP_FREE( url );
1377
1377
                *ludpp = ludp;
1382
1382
        p = q;
1383
1383
        q = strchr( p, '?' );
1384
1384
 
1385
 
        if ( q != NULL ) {
 
1385
        if (q != NULL) {
1386
1386
                /* extra '?' */
1387
1387
                LDAP_FREE( url );
1388
1388
                ldap_free_urldesc( ludp );
1392
1392
        /* parse the extensions */
1393
1393
        ludp->lud_exts = ldap_str2charray( p, "," );
1394
1394
 
1395
 
        if ( ludp->lud_exts == NULL ) {
 
1395
        if (ludp->lud_exts == NULL) {
1396
1396
                LDAP_FREE( url );
1397
1397
                ldap_free_urldesc( ludp );
1398
1398
                return LDAP_URL_ERR_BADEXTS;
1401
1401
        for ( i=0; ludp->lud_exts[i] != NULL; i++ ) {
1402
1402
                ldap_pvt_hex_unescape( ludp->lud_exts[i] );
1403
1403
 
1404
 
                if ( *ludp->lud_exts[i] == '!' ) {
 
1404
                if (*ludp->lud_exts[i] == '!') {
1405
1405
                        /* count the number of critical extensions */
1406
1406
                        ludp->lud_crit_exts++;
1407
1407
                }
1408
1408
        }
1409
1409
 
1410
 
        if ( i == 0 ) {
 
1410
        if (i == 0) {
1411
1411
                /* must have 1 or more */
1412
1412
                LDAP_FREE( url );
1413
1413
                ldap_free_urldesc( ludp );
1425
1425
{
1426
1426
        gint rc = ldap_url_parse_ext( url_in, ludpp );
1427
1427
 
1428
 
        if ( rc != LDAP_URL_SUCCESS ) {
 
1428
        if (rc != LDAP_URL_SUCCESS) {
1429
1429
                return rc;
1430
1430
        }
1431
1431
 
1439
1439
        }
1440
1440
 
1441
1441
        if ((*ludpp)->lud_port == 0) {
1442
 
                if ( strcmp((*ludpp)->lud_scheme, "ldap") == 0 ) {
 
1442
                if (strcmp((*ludpp)->lud_scheme, "ldap") == 0) {
1443
1443
                        (*ludpp)->lud_port = LDAP_PORT;
1444
1444
#ifdef LDAP_CONNECTIONLESS
1445
 
                } else if ( strcmp((*ludpp)->lud_scheme, "cldap") == 0 ) {
 
1445
                } else if (strcmp((*ludpp)->lud_scheme, "cldap") == 0) {
1446
1446
                        (*ludpp)->lud_port = LDAP_PORT;
1447
1447
#endif
1448
 
                } else if ( strcmp((*ludpp)->lud_scheme, "ldaps") == 0 ) {
 
1448
                } else if (strcmp((*ludpp)->lud_scheme, "ldaps") == 0) {
1449
1449
                        (*ludpp)->lud_port = LDAPS_PORT;
1450
1450
                }
1451
1451
        }