← Back to branch summary

~ubuntu-branches/ubuntu/maverick/opendkim/maverick

« back to all changes in this revision

Viewing changes to libopendkim/dkim.c

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-08-11 04:01:22 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20100811040122-ai6d30m3j43nwh1y
Tags: 2.1.3+dfsg-0ubuntu1
* New upstream release
  - Repacked tarball to remove non-free IETF drafts and RFCs
  - Updated Makefile.in/am to not try to install no longer exisitng files
  - Rename libopendkim1 to libopendkim2 to match upstream soname bump
  - Bump libopendkim-dev build-depends to libopendkim2
  - Update debian/rules
  - Rename libopendkim1.docs and .install

Show diffs side-by-side

added added

removed removed

Lines of Context:
libopendkim/dkim.c
6
6
*/
7
7
 
8
8
#ifndef lint
9
 
static char dkim_c_id[] = "@(#)$Id: dkim.c,v 1.45.2.6 2010/04/07 19:23:17 cm-msk Exp $";
 
9
static char dkim_c_id[] = "@(#)$Id: dkim.c,v 1.53.2.2 2010/07/08 23:50:10 cm-msk Exp $";
10
10
#endif /* !lint */
11
11
 
12
12
#include "build-config.h"
120
120
 
121
121
#define DEFCLOCKDRIFT           300
122
122
#define DEFTIMEOUT              10
 
123
#define MINSIGLEN               8
123
124
 
124
125
/* local definitions needed for DNS queries */
125
126
#define MAXPACKET               8192
715
716
                        if (value[0] == '-')
716
717
                        {
717
718
                                errno = ERANGE;
718
 
                                tmp = 0;
 
719
                                tmp = (unsigned long long) -1;
719
720
                        }
720
721
                        else if (value[0] == '\0')
721
722
                        {
722
723
                                errno = EINVAL;
723
 
                                tmp = 0;
 
724
                                tmp = (unsigned long long) -1;
724
725
                        }
725
726
                        else
726
727
                        {
727
728
                                tmp = strtoull(value, &end, 10);
728
729
                        }
729
730
 
730
 
                        if (tmp == ULLONG_MAX || errno != 0 || *end != '\0')
 
731
                        if (tmp == (unsigned long long) -1 || errno != 0 ||
 
732
                            *end != '\0')
731
733
                        {
732
734
                                dkim_error(dkim,
733
735
                                           "invalid \"t\" value in %s data",
751
753
                        if (value[0] == '-')
752
754
                        {
753
755
                                errno = ERANGE;
754
 
                                tmp = 0;
 
756
                                tmp = (unsigned long long) -1;
755
757
                        }
756
758
                        else if (value[0] == '\0')
757
759
                        {
758
760
                                errno = EINVAL;
759
 
                                tmp = 0;
 
761
                                tmp = (unsigned long long) -1;
760
762
                        }
761
763
                        else
762
764
                        {
763
765
                                tmp = strtoull(value, &end, 10);
764
766
                        }
765
767
 
766
 
                        if (tmp == ULLONG_MAX || errno != 0 || *end != '\0')
 
768
                        if (tmp == (unsigned long long) -1 || errno != 0 ||
 
769
                            *end != '\0')
767
770
                        {
768
771
                                dkim_error(dkim,
769
772
                                           "invalid \"x\" value in %s data",
3159
3162
 
3160
3163
                /* no good ones */
3161
3164
                if (!good)
 
3165
                {
 
3166
                        /* report error on the last one */
 
3167
                        if (sig->sig_error != DKIM_SIGERROR_UNKNOWN &&
 
3168
                            sig->sig_error != DKIM_SIGERROR_OK)
 
3169
                        {
 
3170
                                dkim_error(dkim,
 
3171
                                           dkim_code_to_name(sigerrors,
 
3172
                                                             sig->sig_error));
 
3173
                        }
 
3174
 
3162
3175
                        return DKIM_STAT_CANTVRFY;
 
3176
                }
3163
3177
        }
3164
3178
 
3165
3179
        return DKIM_STAT_OK;
3182
3196
        u_int l;
3183
3197
        size_t diglen;
3184
3198
        size_t siglen = 0;
3185
 
        size_t n;
3186
3199
        size_t len;
3187
3200
        DKIM_STAT ret;
3188
3201
        u_char *digest;
3911
3924
                free(libhandle);
3912
3925
                return NULL;
3913
3926
        }
3914
 
# ifdef _FFR_DNS_UPGRADE
 
3927
# ifdef _FFR_DNSUPGRADE
3915
3928
        libhandle->dkiml_arlibtcp = ar_init(NULL, NULL, NULL, AR_FLAG_USETCP);
3916
3929
        if (libhandle->dkiml_arlibtcp == NULL)
3917
3930
        {
3919
3932
                free(libhandle);
3920
3933
                return NULL;
3921
3934
        }
3922
 
# endif /* _FFR_DNS_UPGRADE */
 
3935
# endif /* _FFR_DNSUPGRADE */
3923
3936
#else /* USE_ARLIB */
3924
3937
        (void) res_init();
3925
3938
#endif /* USE_ARLIB */
3951
3964
        if (lib->dkiml_arlib != NULL)
3952
3965
                (void) ar_shutdown(lib->dkiml_arlib);
3953
3966
 
3954
 
# ifdef _FFR_DNS_UPGRADE
 
3967
# ifdef _FFR_DNSUPGRADE
3955
3968
        if (lib->dkiml_arlibtcp != NULL)
3956
3969
                (void) ar_shutdown(lib->dkiml_arlibtcp);
3957
 
# endif /* _FFR_DNS_UPGRADE */
 
3970
# endif /* _FFR_DNSUPGRADE */
3958
3971
#endif /* USE_ARLIB */
3959
3972
 
3960
3973
#ifdef USE_UNBOUND
6721
6734
                *msglen = dkim->dkim_bodylen;
6722
6735
 
6723
6736
        if (canonlen != NULL)
 
6737
        {
 
6738
                if (sig->sig_bodycanon == NULL)
 
6739
                        return DKIM_STAT_INTERNAL;
6724
6740
                *canonlen = sig->sig_bodycanon->canon_wrote;
 
6741
        }
6725
6742
 
6726
6743
        if (signlen != NULL)
 
6744
        {
 
6745
                if (sig->sig_bodycanon == NULL)
 
6746
                        return DKIM_STAT_INTERNAL;
6727
6747
                *signlen = sig->sig_bodycanon->canon_length;
 
6748
        }
6728
6749
 
6729
6750
        return DKIM_STAT_OK;
6730
6751
}
7630
7651
}
7631
7652
 
7632
7653
/*
 
7654
**  DKIM_GET_SIGSUBSTRING -- retrieve a minimal signature substring for
 
7655
**                           disambiguation
 
7656
**
 
7657
**  Parameters:
 
7658
**      dkim -- DKIM handle
 
7659
**      sig -- DKIM_SIGINFO handle
 
7660
**      buf -- buffer into which to put the substring
 
7661
**      buflen -- bytes available at "buf"
 
7662
**
 
7663
**  Return value:
 
7664
**      A DKIM_STAT_* constant.
 
7665
*/
 
7666
 
 
7667
DKIM_STAT
 
7668
dkim_get_sigsubstring(DKIM *dkim, DKIM_SIGINFO *sig, char *buf, size_t *buflen)
 
7669
{
 
7670
        int c;
 
7671
        int d;
 
7672
        int x;
 
7673
        int b1len;
 
7674
        int b2len;
 
7675
        int minlen;
 
7676
        char *b1;
 
7677
        char *b2;
 
7678
 
 
7679
        assert(dkim != NULL);
 
7680
        assert(sig != NULL);
 
7681
        assert(buf != NULL);
 
7682
        assert(buflen != NULL);
 
7683
 
 
7684
        if (dkim->dkim_minsiglen == 0)
 
7685
        {
 
7686
                dkim->dkim_minsiglen = MINSIGLEN;
 
7687
 
 
7688
                for (c = 0; c < dkim->dkim_sigcount - 1; c++)
 
7689
                {
 
7690
                        b1 = dkim_param_get(dkim->dkim_siglist[c]->sig_taglist,
 
7691
                                            "b");
 
7692
                        if (b1 == NULL)
 
7693
                                continue;
 
7694
 
 
7695
                        b1len = strlen(b1);
 
7696
 
 
7697
                        for (d = c + 1; d < dkim->dkim_sigcount; d++)
 
7698
                        {
 
7699
                                b2 = dkim_param_get(dkim->dkim_siglist[d]->sig_taglist,
 
7700
                                                    "b");
 
7701
                                if (b2 == NULL)
 
7702
                                        continue;
 
7703
 
 
7704
                                if (strncmp(b1, b2, dkim->dkim_minsiglen) != 0)
 
7705
                                        continue;
 
7706
 
 
7707
                                b2len = strlen(b2);
 
7708
 
 
7709
                                minlen = MIN(strlen(b1), strlen(b2));
 
7710
 
 
7711
                                for (x = dkim->dkim_minsiglen; x < minlen; x++)
 
7712
                                {
 
7713
                                        if (b1[x] != b2[x])
 
7714
                                                break;
 
7715
                                }
 
7716
 
 
7717
                                dkim->dkim_minsiglen = x + 1;
 
7718
                        }
 
7719
                }
 
7720
        }
 
7721
 
 
7722
        b1 = dkim_param_get(sig->sig_taglist, "b");
 
7723
        if (b1 == NULL)
 
7724
                return DKIM_STAT_SYNTAX;
 
7725
 
 
7726
        minlen = MIN(*buflen, dkim->dkim_minsiglen);
 
7727
        strncpy(buf, b1, minlen);
 
7728
        *buflen = minlen;
 
7729
 
 
7730
        return DKIM_STAT_OK;
 
7731
}
 
7732
 
 
7733
/*
7633
7734
**  DKIM_LIBFEATURE -- determine whether or not a particular library feature
7634
7735
**                     is actually available
7635
7736
**
7670
7771
{
7671
7772
        return OPENDKIM_LIB_VERSION;
7672
7773
}
 
7774
 
 
7775
/*
 
7776
**  DKIM_SIG_GETTAGVALUE -- retrieve a tag's value from a signature or its key
 
7777
**
 
7778
**  Parameters:
 
7779
**      sig -- DKIM_SIGINFO handle
 
7780
**      keytag -- TRUE iff we want a key's tag
 
7781
**      tag -- name of the tag of interest
 
7782
**
 
7783
**  Return value:
 
7784
**      Pointer to the string containing the value of the requested key,
 
7785
**      or NULL if not present.
 
7786
**
 
7787
**  Notes:
 
7788
**      This was added for use in determining whether or not a key or
 
7789
**      signature contained particular data, for gathering general statistics
 
7790
**      about DKIM use.  It is not intended to give applications direct access
 
7791
**      to unprocessed signature or key data.  The data returned has not
 
7792
**      necessarily been vetted in any way.  Caveat emptor.
 
7793
*/
 
7794
 
 
7795
u_char *
 
7796
dkim_sig_gettagvalue(DKIM_SIGINFO *sig, _Bool keytag, char *tag)
 
7797
{
 
7798
        DKIM_SET *set;
 
7799
 
 
7800
        assert(sig != NULL);
 
7801
        assert(tag != NULL);
 
7802
 
 
7803
        if (keytag)
 
7804
                set = sig->sig_keytaglist;
 
7805
        else
 
7806
                set = sig->sig_taglist;
 
7807
 
 
7808
        if (set == NULL)
 
7809
                return NULL;
 
7810
        else
 
7811
                return dkim_param_get(set, tag);
 
7812
}