diff --git a/mail/fdm/Makefile b/mail/fdm/Makefile index 7328c5526..10396db2a 100644 --- a/mail/fdm/Makefile +++ b/mail/fdm/Makefile @@ -9,13 +9,16 @@ include $(TOPDIR)/rules.mk PKG_NAME:=fdm PKG_VERSION:=1.9 -PKG_RELEASE:=3 +PKG_RELEASE:=4 PKG_LICENSE:=BSD-2-Clause -PKG_SOURCE:=$(PKG_VERSION).zip -PKG_SOURCE_URL:=https://github.com/nicm/fdm/archive -PKG_HASH:=ee08f9133657c8c959b738079c2e4f556cf5cca2daa8343feaf4f07698ad6086 +PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz +PKG_SOURCE_URL:=https://github.com/nicm/fdm/releases/download/$(PKG_VERSION) +PKG_HASH:=16416c38a9a7e32d187220cc5ae61a51463d5e4e47419c5c513f422523d39914 +PKG_FIXUP:=autoreconf + +PKG_BUILD_PARALLEL:=1 PKG_INSTALL:=1 include $(INCLUDE_DIR)/package.mk @@ -24,7 +27,7 @@ define Package/fdm SECTION:=mail CATEGORY:=Mail TITLE:=fetch mail and deliver - URL:=http://fdm.sourceforge.net/ + URL:=https://github.com/nicm/fdm MAINTAINER:=Dmitry V. Zimin MENU:=1 DEPENDS:=+tdb +zlib +libopenssl +FDM_WITH_PCRE:libpcre @@ -47,16 +50,6 @@ MAKE_FLAGS += \ PREFIX="/usr" \ $(if $(CONFIG_FDM_WITH_PCRE),PCRE=1) -define Build/Prepare - $(call Build/Prepare/Default) - $(CP) ./src/compat/* $(PKG_BUILD_DIR)/ -endef - -define Build/Configure - ( cd $(PKG_BUILD_DIR); ./autogen.sh ) - $(call Build/Configure/Default) -endef - define Package/fdm/config source "$(SOURCE)/Config.in" endef diff --git a/mail/fdm/patches/001-base64-fix.patch b/mail/fdm/patches/001-base64-fix.patch deleted file mode 100644 index ad9239bf0..000000000 --- a/mail/fdm/patches/001-base64-fix.patch +++ /dev/null @@ -1,14 +0,0 @@ ---- a/fdm.h 2011-10-10 17:36:29.000000000 +0400 -+++ b/fdm.h 2014-11-13 12:56:59.217083683 +0300 -@@ -719,6 +719,11 @@ - size_t strlcat(char *, const char *, size_t); - #endif - -+int local_b64_ntop(uint8_t const *src, size_t srclength, char *target, -+ size_t targsize); -+ -+int local_b64_pton(char const *src, uint8_t *target, size_t targsize); -+ - /* shm.c */ - char *shm_path(struct shm *); - void *shm_create(struct shm *, size_t); diff --git a/mail/fdm/patches/002-base64-fix.patch b/mail/fdm/patches/002-base64-fix.patch deleted file mode 100644 index 7f798a6ec..000000000 --- a/mail/fdm/patches/002-base64-fix.patch +++ /dev/null @@ -1,20 +0,0 @@ ---- a/imap-common.c 2011-12-20 00:19:03.000000000 +0400 -+++ b/imap-common.c 2014-11-13 12:56:06.930418446 +0300 -@@ -206,7 +206,7 @@ - - size = (strlen(in) * 2) + 1; - out = xcalloc(1, size); -- if (b64_ntop(in, strlen(in), out, size) < 0) { -+ if (local_b64_ntop(in, strlen(in), out, size) < 0) { - xfree(out); - return (NULL); - } -@@ -222,7 +222,7 @@ - - size = (strlen(in) * 4) + 1; - out = xcalloc(1, size); -- if (b64_pton(in, out, size) < 0) { -+ if (local_b64_pton(in, out, size) < 0) { - xfree(out); - return (NULL); - } diff --git a/mail/fdm/patches/003-base64-fix.patch b/mail/fdm/patches/003-base64-fix.patch deleted file mode 100644 index 2964568b0..000000000 --- a/mail/fdm/patches/003-base64-fix.patch +++ /dev/null @@ -1,15 +0,0 @@ -Index: fdm-1.9/Makefile.am -=================================================================== ---- fdm-1.9.orig/Makefile.am -+++ fdm-1.9/Makefile.am -@@ -107,7 +107,9 @@ dist_fdm_SOURCES = \ - xmalloc.c \ - \ - parse.y \ -- lex.c -+ lex.c \ -+ b64_ntop.c \ -+ b64_pton.c - - nodist_fdm_SOURCES = - if NO_STRLCAT diff --git a/mail/fdm/patches/010-Compat-fixes-from-Rosen-Penev.patch b/mail/fdm/patches/010-Compat-fixes-from-Rosen-Penev.patch new file mode 100644 index 000000000..4a9272510 --- /dev/null +++ b/mail/fdm/patches/010-Compat-fixes-from-Rosen-Penev.patch @@ -0,0 +1,388 @@ +From eb7461e4ceab14020b3a129d826e4ee86f9da8c6 Mon Sep 17 00:00:00 2001 +From: Nicholas Marriott +Date: Tue, 26 Jun 2018 12:19:25 +0100 +Subject: [PATCH] Compat fixes from Rosen Penev. + +--- + Makefile.am | 6 + + compat/base64.c | 317 ++++++++++++++++++++++++++++++++++++++++++++++++ + fdm.h | 18 +++ + 3 files changed, 343 insertions(+), 2 deletions(-) + create mode 100644 compat/base64.c + +diff --git a/Makefile.am b/Makefile.am +index a4ebbf3..fb25d33 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -110,6 +110,9 @@ dist_fdm_SOURCES = \ + lex.c + + nodist_fdm_SOURCES = ++if NO_B64_NTOP ++nodist_fdm_SOURCES += compat/base64.c ++endif + if NO_STRLCAT + nodist_fdm_SOURCES += compat/strlcat.c + endif +diff --git a/compat/base64.c b/compat/base64.c +new file mode 100644 +index 0000000..4e44d6a +--- /dev/null ++++ b/compat/base64.c +@@ -0,0 +1,317 @@ ++/* $OpenBSD: base64.c,v 1.8 2015/01/16 16:48:51 deraadt Exp $ */ ++ ++/* ++ * Copyright (c) 1996 by Internet Software Consortium. ++ * ++ * Permission to use, copy, modify, and distribute this software for any ++ * purpose with or without fee is hereby granted, provided that the above ++ * copyright notice and this permission notice appear in all copies. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS ++ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES ++ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE ++ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL ++ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR ++ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ++ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ++ * SOFTWARE. ++ */ ++ ++/* ++ * Portions Copyright (c) 1995 by International Business Machines, Inc. ++ * ++ * International Business Machines, Inc. (hereinafter called IBM) grants ++ * permission under its copyrights to use, copy, modify, and distribute this ++ * Software with or without fee, provided that the above copyright notice and ++ * all paragraphs of this notice appear in all copies, and that the name of IBM ++ * not be used in connection with the marketing of any product incorporating ++ * the Software or modifications thereof, without specific, written prior ++ * permission. ++ * ++ * To the extent it has a right to do so, IBM grants an immunity from suit ++ * under its patents, if any, for the use, sale or manufacture of products to ++ * the extent that such products are used for performing Domain Name System ++ * dynamic updates in TCP/IP networks by means of the Software. No immunity is ++ * granted for any product per se or for any other function of any product. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, ++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A ++ * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, ++ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING ++ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN ++ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include "fdm.h" ++ ++static const char Base64[] = ++ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; ++static const char Pad64 = '='; ++ ++/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt) ++ The following encoding technique is taken from RFC 1521 by Borenstein ++ and Freed. It is reproduced here in a slightly edited form for ++ convenience. ++ ++ A 65-character subset of US-ASCII is used, enabling 6 bits to be ++ represented per printable character. (The extra 65th character, "=", ++ is used to signify a special processing function.) ++ ++ The encoding process represents 24-bit groups of input bits as output ++ strings of 4 encoded characters. Proceeding from left to right, a ++ 24-bit input group is formed by concatenating 3 8-bit input groups. ++ These 24 bits are then treated as 4 concatenated 6-bit groups, each ++ of which is translated into a single digit in the base64 alphabet. ++ ++ Each 6-bit group is used as an index into an array of 64 printable ++ characters. The character referenced by the index is placed in the ++ output string. ++ ++ Table 1: The Base64 Alphabet ++ ++ Value Encoding Value Encoding Value Encoding Value Encoding ++ 0 A 17 R 34 i 51 z ++ 1 B 18 S 35 j 52 0 ++ 2 C 19 T 36 k 53 1 ++ 3 D 20 U 37 l 54 2 ++ 4 E 21 V 38 m 55 3 ++ 5 F 22 W 39 n 56 4 ++ 6 G 23 X 40 o 57 5 ++ 7 H 24 Y 41 p 58 6 ++ 8 I 25 Z 42 q 59 7 ++ 9 J 26 a 43 r 60 8 ++ 10 K 27 b 44 s 61 9 ++ 11 L 28 c 45 t 62 + ++ 12 M 29 d 46 u 63 / ++ 13 N 30 e 47 v ++ 14 O 31 f 48 w (pad) = ++ 15 P 32 g 49 x ++ 16 Q 33 h 50 y ++ ++ Special processing is performed if fewer than 24 bits are available ++ at the end of the data being encoded. A full encoding quantum is ++ always completed at the end of a quantity. When fewer than 24 input ++ bits are available in an input group, zero bits are added (on the ++ right) to form an integral number of 6-bit groups. Padding at the ++ end of the data is performed using the '=' character. ++ ++ Since all base64 input is an integral number of octets, only the ++ ------------------------------------------------- ++ following cases can arise: ++ ++ (1) the final quantum of encoding input is an integral ++ multiple of 24 bits; here, the final unit of encoded ++ output will be an integral multiple of 4 characters ++ with no "=" padding, ++ (2) the final quantum of encoding input is exactly 8 bits; ++ here, the final unit of encoded output will be two ++ characters followed by two "=" padding characters, or ++ (3) the final quantum of encoding input is exactly 16 bits; ++ here, the final unit of encoded output will be three ++ characters followed by one "=" padding character. ++ */ ++ ++int ++b64_ntop(src, srclength, target, targsize) ++ u_char const *src; ++ size_t srclength; ++ char *target; ++ size_t targsize; ++{ ++ size_t datalength = 0; ++ u_char input[3]; ++ u_char output[4]; ++ int i; ++ ++ while (2 < srclength) { ++ input[0] = *src++; ++ input[1] = *src++; ++ input[2] = *src++; ++ srclength -= 3; ++ ++ output[0] = input[0] >> 2; ++ output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); ++ output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); ++ output[3] = input[2] & 0x3f; ++ ++ if (datalength + 4 > targsize) ++ return (-1); ++ target[datalength++] = Base64[output[0]]; ++ target[datalength++] = Base64[output[1]]; ++ target[datalength++] = Base64[output[2]]; ++ target[datalength++] = Base64[output[3]]; ++ } ++ ++ /* Now we worry about padding. */ ++ if (0 != srclength) { ++ /* Get what's left. */ ++ input[0] = input[1] = input[2] = '\0'; ++ for (i = 0; i < srclength; i++) ++ input[i] = *src++; ++ ++ output[0] = input[0] >> 2; ++ output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); ++ output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); ++ ++ if (datalength + 4 > targsize) ++ return (-1); ++ target[datalength++] = Base64[output[0]]; ++ target[datalength++] = Base64[output[1]]; ++ if (srclength == 1) ++ target[datalength++] = Pad64; ++ else ++ target[datalength++] = Base64[output[2]]; ++ target[datalength++] = Pad64; ++ } ++ if (datalength >= targsize) ++ return (-1); ++ target[datalength] = '\0'; /* Returned value doesn't count \0. */ ++ return (datalength); ++} ++ ++/* skips all whitespace anywhere. ++ converts characters, four at a time, starting at (or after) ++ src from base - 64 numbers into three 8 bit bytes in the target area. ++ it returns the number of data bytes stored at the target, or -1 on error. ++ */ ++ ++int ++b64_pton(src, target, targsize) ++ char const *src; ++ u_char *target; ++ size_t targsize; ++{ ++ int tarindex, state, ch; ++ u_char nextbyte; ++ char *pos; ++ ++ state = 0; ++ tarindex = 0; ++ ++ while ((ch = (unsigned char)*src++) != '\0') { ++ if (isspace(ch)) /* Skip whitespace anywhere. */ ++ continue; ++ ++ if (ch == Pad64) ++ break; ++ ++ pos = strchr(Base64, ch); ++ if (pos == 0) /* A non-base64 character. */ ++ return (-1); ++ ++ switch (state) { ++ case 0: ++ if (target) { ++ if (tarindex >= targsize) ++ return (-1); ++ target[tarindex] = (pos - Base64) << 2; ++ } ++ state = 1; ++ break; ++ case 1: ++ if (target) { ++ if (tarindex >= targsize) ++ return (-1); ++ target[tarindex] |= (pos - Base64) >> 4; ++ nextbyte = ((pos - Base64) & 0x0f) << 4; ++ if (tarindex + 1 < targsize) ++ target[tarindex+1] = nextbyte; ++ else if (nextbyte) ++ return (-1); ++ } ++ tarindex++; ++ state = 2; ++ break; ++ case 2: ++ if (target) { ++ if (tarindex >= targsize) ++ return (-1); ++ target[tarindex] |= (pos - Base64) >> 2; ++ nextbyte = ((pos - Base64) & 0x03) << 6; ++ if (tarindex + 1 < targsize) ++ target[tarindex+1] = nextbyte; ++ else if (nextbyte) ++ return (-1); ++ } ++ tarindex++; ++ state = 3; ++ break; ++ case 3: ++ if (target) { ++ if (tarindex >= targsize) ++ return (-1); ++ target[tarindex] |= (pos - Base64); ++ } ++ tarindex++; ++ state = 0; ++ break; ++ } ++ } ++ ++ /* ++ * We are done decoding Base-64 chars. Let's see if we ended ++ * on a byte boundary, and/or with erroneous trailing characters. ++ */ ++ ++ if (ch == Pad64) { /* We got a pad char. */ ++ ch = (unsigned char)*src++; /* Skip it, get next. */ ++ switch (state) { ++ case 0: /* Invalid = in first position */ ++ case 1: /* Invalid = in second position */ ++ return (-1); ++ ++ case 2: /* Valid, means one byte of info */ ++ /* Skip any number of spaces. */ ++ for (; ch != '\0'; ch = (unsigned char)*src++) ++ if (!isspace(ch)) ++ break; ++ /* Make sure there is another trailing = sign. */ ++ if (ch != Pad64) ++ return (-1); ++ ch = (unsigned char)*src++; /* Skip the = */ ++ /* Fall through to "single trailing =" case. */ ++ /* FALLTHROUGH */ ++ ++ case 3: /* Valid, means two bytes of info */ ++ /* ++ * We know this char is an =. Is there anything but ++ * whitespace after it? ++ */ ++ for (; ch != '\0'; ch = (unsigned char)*src++) ++ if (!isspace(ch)) ++ return (-1); ++ ++ /* ++ * Now make sure for cases 2 and 3 that the "extra" ++ * bits that slopped past the last full byte were ++ * zeros. If we don't check them, they become a ++ * subliminal channel. ++ */ ++ if (target && tarindex < targsize && ++ target[tarindex] != 0) ++ return (-1); ++ } ++ } else { ++ /* ++ * We ended by seeing the end of the string. Make sure we ++ * have no partial bytes lying around. ++ */ ++ if (state != 0) ++ return (-1); ++ } ++ ++ return (tarindex); ++} +diff --git a/fdm.h b/fdm.h +index 5de799c..abc52e0 100644 +--- a/fdm.h ++++ b/fdm.h +@@ -84,6 +84,18 @@ extern char *__progname; + #define INFTIM -1 + #endif + ++#ifndef WAIT_ANY ++#define WAIT_ANY -1 ++#endif ++ ++#ifndef GLOB_BRACE ++#define GLOB_BRACE 0 ++#endif ++ ++#ifndef ACCESSPERMS ++#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO) ++#endif ++ + #ifndef __dead + #define __dead __attribute__ ((__noreturn__)) + #endif +@@ -707,6 +719,12 @@ size_t strlcpy(char *, const char *, size_t); + size_t strlcat(char *, const char *, size_t); + #endif + ++#ifndef HAVE_B64_NTOP ++/* base64.c */ ++int b64_ntop(src, srclength, target, targsize); ++int b64_pton(src, target, targsize); ++#endif ++ + /* shm.c */ + char *shm_path(struct shm *); + void *shm_create(struct shm *, size_t); +-- +2.17.1 + diff --git a/mail/fdm/patches/010-musl_WAIT_ANY.patch b/mail/fdm/patches/010-musl_WAIT_ANY.patch deleted file mode 100644 index d37bc7f03..000000000 --- a/mail/fdm/patches/010-musl_WAIT_ANY.patch +++ /dev/null @@ -1,13 +0,0 @@ ---- a/fdm.c -+++ b/fdm.c -@@ -22,6 +22,10 @@ - #include - #include - -+#ifndef WAIT_ANY -+#define WAIT_ANY (-1) -+#endif -+ - #include - #include - #include diff --git a/mail/fdm/patches/020-Fix-compile-with-OpenSSL-1.1.0.patch b/mail/fdm/patches/020-Fix-compile-with-OpenSSL-1.1.0.patch new file mode 100644 index 000000000..9ce23642a --- /dev/null +++ b/mail/fdm/patches/020-Fix-compile-with-OpenSSL-1.1.0.patch @@ -0,0 +1,32 @@ +From f6c656c5c0368b2fb4284af0484c3bedfc7ae42c Mon Sep 17 00:00:00 2001 +From: Rosen Penev +Date: Tue, 26 Jun 2018 14:14:34 -0700 +Subject: [PATCH] Fix compile with OpenSSL 1.1.0 + +OpenSSL 1.1.0 deprecared SSL_library_init and SSL_load_error_strings. +They're part of OPENSSL_init_ssl now. +--- + fdm.c | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/fdm.c b/fdm.c +index cdf8383..9355b91 100644 +--- a/fdm.c ++++ b/fdm.c +@@ -717,8 +717,13 @@ retry: + } + conf.lock_file = lock; + ++ ++#if OPENSSL_VERSION_NUMBER < 0x10100000L + SSL_library_init(); + SSL_load_error_strings(); ++#else ++ OPENSSL_init_ssl(0, NULL); ++#endif + + /* Filter account list. */ + TAILQ_INIT(&actaq); +-- +2.17.1 + diff --git a/mail/fdm/patches/020-musl_GLOB_BRACE.patch b/mail/fdm/patches/020-musl_GLOB_BRACE.patch deleted file mode 100644 index 2b5683d1f..000000000 --- a/mail/fdm/patches/020-musl_GLOB_BRACE.patch +++ /dev/null @@ -1,22 +0,0 @@ ---- a/fetch-maildir.c -+++ b/fetch-maildir.c -@@ -31,6 +31,8 @@ - #include "fdm.h" - #include "fetch.h" - -+#define GLOB_BRACE 0 -+ - int fetch_maildir_commit(struct account *, struct mail *); - void fetch_maildir_abort(struct account *); - u_int fetch_maildir_total(struct account *); ---- a/fetch-mbox.c -+++ b/fetch-mbox.c -@@ -32,6 +32,8 @@ - #include "fdm.h" - #include "fetch.h" - -+#define GLOB_BRACE 0 -+ - int fetch_mbox_commit(struct account *, struct mail *); - void fetch_mbox_abort(struct account *); - u_int fetch_mbox_total(struct account *); diff --git a/mail/fdm/patches/030-musl_ACCESSPERMS.patch b/mail/fdm/patches/030-musl_ACCESSPERMS.patch deleted file mode 100644 index b781871b2..000000000 --- a/mail/fdm/patches/030-musl_ACCESSPERMS.patch +++ /dev/null @@ -1,11 +0,0 @@ ---- a/file.c -+++ b/file.c -@@ -26,6 +26,8 @@ - - #include "fdm.h" - -+#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO) -+ - int mklock(u_int, const char *); - void rmlock(u_int, const char *); - int lockfd(u_int, int); diff --git a/mail/fdm/src/compat/b64_ntop.c b/mail/fdm/src/compat/b64_ntop.c deleted file mode 100644 index 0d222cf1f..000000000 --- a/mail/fdm/src/compat/b64_ntop.c +++ /dev/null @@ -1,183 +0,0 @@ -/* - * Copyright (c) 1996, 1998 by Internet Software Consortium. - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS - * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE - * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL - * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR - * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS - * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS - * SOFTWARE. - */ - -/* - * Portions Copyright (c) 1995 by International Business Machines, Inc. - * - * International Business Machines, Inc. (hereinafter called IBM) grants - * permission under its copyrights to use, copy, modify, and distribute this - * Software with or without fee, provided that the above copyright notice and - * all paragraphs of this notice appear in all copies, and that the name of IBM - * not be used in connection with the marketing of any product incorporating - * the Software or modifications thereof, without specific, written prior - * permission. - * - * To the extent it has a right to do so, IBM grants an immunity from suit - * under its patents, if any, for the use, sale or manufacture of products to - * the extent that such products are used for performing Domain Name System - * dynamic updates in TCP/IP networks by means of the Software. No immunity is - * granted for any product per se or for any other function of any product. - * - * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, - * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A - * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, - * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN - * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. - */ -//#include - -#include -#include -#include - -#include -#include - -#include -#include -#include -#include - -#include "fdm.h" - -#define Assert(Cond) if (!(Cond)) abort() - -static const char Base64[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -static const char Pad64 = '='; - -/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt) - The following encoding technique is taken from RFC 1521 by Borenstein - and Freed. It is reproduced here in a slightly edited form for - convenience. - - A 65-character subset of US-ASCII is used, enabling 6 bits to be - represented per printable character. (The extra 65th character, "=", - is used to signify a special processing function.) - - The encoding process represents 24-bit groups of input bits as output - strings of 4 encoded characters. Proceeding from left to right, a - 24-bit input group is formed by concatenating 3 8-bit input groups. - These 24 bits are then treated as 4 concatenated 6-bit groups, each - of which is translated into a single digit in the base64 alphabet. - - Each 6-bit group is used as an index into an array of 64 printable - characters. The character referenced by the index is placed in the - output string. - - Table 1: The Base64 Alphabet - - Value Encoding Value Encoding Value Encoding Value Encoding - 0 A 17 R 34 i 51 z - 1 B 18 S 35 j 52 0 - 2 C 19 T 36 k 53 1 - 3 D 20 U 37 l 54 2 - 4 E 21 V 38 m 55 3 - 5 F 22 W 39 n 56 4 - 6 G 23 X 40 o 57 5 - 7 H 24 Y 41 p 58 6 - 8 I 25 Z 42 q 59 7 - 9 J 26 a 43 r 60 8 - 10 K 27 b 44 s 61 9 - 11 L 28 c 45 t 62 + - 12 M 29 d 46 u 63 / - 13 N 30 e 47 v - 14 O 31 f 48 w (pad) = - 15 P 32 g 49 x - 16 Q 33 h 50 y - - Special processing is performed if fewer than 24 bits are available - at the end of the data being encoded. A full encoding quantum is - always completed at the end of a quantity. When fewer than 24 input - bits are available in an input group, zero bits are added (on the - right) to form an integral number of 6-bit groups. Padding at the - end of the data is performed using the '=' character. - - Since all base64 input is an integral number of octets, only the - following cases can arise: - - (1) the final quantum of encoding input is an integral - multiple of 24 bits; here, the final unit of encoded - output will be an integral multiple of 4 characters - with no "=" padding, - (2) the final quantum of encoding input is exactly 8 bits; - here, the final unit of encoded output will be two - characters followed by two "=" padding characters, or - (3) the final quantum of encoding input is exactly 16 bits; - here, the final unit of encoded output will be three - characters followed by one "=" padding character. - */ - -int -local_b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) { - size_t datalength = 0; - uint8_t input[3]; - uint8_t output[4]; - size_t i; - - while (2 < srclength) { - input[0] = *src++; - input[1] = *src++; - input[2] = *src++; - srclength -= 3; - - output[0] = input[0] >> 2; - output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); - output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); - output[3] = input[2] & 0x3f; - Assert(output[0] < 64); - Assert(output[1] < 64); - Assert(output[2] < 64); - Assert(output[3] < 64); - - if (datalength + 4 > targsize) - return (-1); - target[datalength++] = Base64[output[0]]; - target[datalength++] = Base64[output[1]]; - target[datalength++] = Base64[output[2]]; - target[datalength++] = Base64[output[3]]; - } - - /* Now we worry about padding. */ - if (0 != srclength) { - /* Get what's left. */ - input[0] = input[1] = input[2] = '\0'; - for (i = 0; i < srclength; i++) - input[i] = *src++; - output[0] = input[0] >> 2; - output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); - output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); - Assert(output[0] < 64); - Assert(output[1] < 64); - Assert(output[2] < 64); - - if (datalength + 4 > targsize) - return (-1); - target[datalength++] = Base64[output[0]]; - target[datalength++] = Base64[output[1]]; - if (srclength == 1) - target[datalength++] = Pad64; - else - target[datalength++] = Base64[output[2]]; - target[datalength++] = Pad64; - } - if (datalength >= targsize) - return (-1); - target[datalength] = '\0'; /* Returned value doesn't count \0. */ - return (datalength); -} diff --git a/mail/fdm/src/compat/b64_pton.c b/mail/fdm/src/compat/b64_pton.c deleted file mode 100644 index 0e9363a95..000000000 --- a/mail/fdm/src/compat/b64_pton.c +++ /dev/null @@ -1,393 +0,0 @@ -/* - * Copyright (c) 1996, 1998 by Internet Software Consortium. - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS - * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE - * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL - * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR - * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS - * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS - * SOFTWARE. - */ - -/* - * Portions Copyright (c) 1995 by International Business Machines, Inc. - * - * International Business Machines, Inc. (hereinafter called IBM) grants - * permission under its copyrights to use, copy, modify, and distribute this - * Software with or without fee, provided that the above copyright notice and - * all paragraphs of this notice appear in all copies, and that the name of IBM - * not be used in connection with the marketing of any product incorporating - * the Software or modifications thereof, without specific, written prior - * permission. - * - * To the extent it has a right to do so, IBM grants an immunity from suit - * under its patents, if any, for the use, sale or manufacture of products to - * the extent that such products are used for performing Domain Name System - * dynamic updates in TCP/IP networks by means of the Software. No immunity is - * granted for any product per se or for any other function of any product. - * - * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, - * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A - * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, - * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN - * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. - */ -//#include - -#include -#include -#include - -#include -#include - -#include -#include -#include -#include - -#include "fdm.h" - -#define Assert(Cond) if (!(Cond)) abort() - -static const char Base64[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -static const char Pad64 = '='; - -/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt) - The following encoding technique is taken from RFC 1521 by Borenstein - and Freed. It is reproduced here in a slightly edited form for - convenience. - - A 65-character subset of US-ASCII is used, enabling 6 bits to be - represented per printable character. (The extra 65th character, "=", - is used to signify a special processing function.) - - The encoding process represents 24-bit groups of input bits as output - strings of 4 encoded characters. Proceeding from left to right, a - 24-bit input group is formed by concatenating 3 8-bit input groups. - These 24 bits are then treated as 4 concatenated 6-bit groups, each - of which is translated into a single digit in the base64 alphabet. - - Each 6-bit group is used as an index into an array of 64 printable - characters. The character referenced by the index is placed in the - output string. - - Table 1: The Base64 Alphabet - - Value Encoding Value Encoding Value Encoding Value Encoding - 0 A 17 R 34 i 51 z - 1 B 18 S 35 j 52 0 - 2 C 19 T 36 k 53 1 - 3 D 20 U 37 l 54 2 - 4 E 21 V 38 m 55 3 - 5 F 22 W 39 n 56 4 - 6 G 23 X 40 o 57 5 - 7 H 24 Y 41 p 58 6 - 8 I 25 Z 42 q 59 7 - 9 J 26 a 43 r 60 8 - 10 K 27 b 44 s 61 9 - 11 L 28 c 45 t 62 + - 12 M 29 d 46 u 63 / - 13 N 30 e 47 v - 14 O 31 f 48 w (pad) = - 15 P 32 g 49 x - 16 Q 33 h 50 y - - Special processing is performed if fewer than 24 bits are available - at the end of the data being encoded. A full encoding quantum is - always completed at the end of a quantity. When fewer than 24 input - bits are available in an input group, zero bits are added (on the - right) to form an integral number of 6-bit groups. Padding at the - end of the data is performed using the '=' character. - - Since all base64 input is an integral number of octets, only the - following cases can arise: - - (1) the final quantum of encoding input is an integral - multiple of 24 bits; here, the final unit of encoded - output will be an integral multiple of 4 characters - with no "=" padding, - (2) the final quantum of encoding input is exactly 8 bits; - here, the final unit of encoded output will be two - characters followed by two "=" padding characters, or - (3) the final quantum of encoding input is exactly 16 bits; - here, the final unit of encoded output will be three - characters followed by one "=" padding character. - */ - -/* skips all whitespace anywhere. - converts characters, four at a time, starting at (or after) - src from base - 64 numbers into three 8 bit bytes in the target area. - it returns the number of data bytes stored at the target, or -1 on error. - */ - -static int b64rmap_initialized = 0; -static uint8_t b64rmap[256]; - -static const uint8_t b64rmap_special = 0xf0; -static const uint8_t b64rmap_end = 0xfd; -static const uint8_t b64rmap_space = 0xfe; -static const uint8_t b64rmap_invalid = 0xff; - -/** - * Initializing the reverse map is not thread safe. - * Which is fine for NSD. For now... - **/ -static void -b64_initialize_rmap () -{ - int i; - char ch; - - /* Null: end of string, stop parsing */ - b64rmap[0] = b64rmap_end; - - for (i = 1; i < 256; ++i) { - ch = (char)i; - /* Whitespaces */ - if (isspace(ch)) - b64rmap[i] = b64rmap_space; - /* Padding: stop parsing */ - else if (ch == Pad64) - b64rmap[i] = b64rmap_end; - /* Non-base64 char */ - else - b64rmap[i] = b64rmap_invalid; - } - - /* Fill reverse mapping for base64 chars */ - for (i = 0; Base64[i] != '\0'; ++i) - b64rmap[(uint8_t)Base64[i]] = i; - - b64rmap_initialized = 1; -} - -static int -b64_pton_do(char const *src, uint8_t *target, size_t targsize) -{ - int tarindex, state, ch; - uint8_t ofs; - - state = 0; - tarindex = 0; - - while (1) - { - ch = *src++; - ofs = b64rmap[ch]; - - if (ofs >= b64rmap_special) { - /* Ignore whitespaces */ - if (ofs == b64rmap_space) - continue; - /* End of base64 characters */ - if (ofs == b64rmap_end) - break; - /* A non-base64 character. */ - return (-1); - } - - switch (state) { - case 0: - if ((size_t)tarindex >= targsize) - return (-1); - target[tarindex] = ofs << 2; - state = 1; - break; - case 1: - if ((size_t)tarindex + 1 >= targsize) - return (-1); - target[tarindex] |= ofs >> 4; - target[tarindex+1] = (ofs & 0x0f) - << 4 ; - tarindex++; - state = 2; - break; - case 2: - if ((size_t)tarindex + 1 >= targsize) - return (-1); - target[tarindex] |= ofs >> 2; - target[tarindex+1] = (ofs & 0x03) - << 6; - tarindex++; - state = 3; - break; - case 3: - if ((size_t)tarindex >= targsize) - return (-1); - target[tarindex] |= ofs; - tarindex++; - state = 0; - break; - default: - abort(); - } - } - - /* - * We are done decoding Base-64 chars. Let's see if we ended - * on a byte boundary, and/or with erroneous trailing characters. - */ - - if (ch == Pad64) { /* We got a pad char. */ - ch = *src++; /* Skip it, get next. */ - switch (state) { - case 0: /* Invalid = in first position */ - case 1: /* Invalid = in second position */ - return (-1); - - case 2: /* Valid, means one byte of info */ - /* Skip any number of spaces. */ - for ((void)NULL; ch != '\0'; ch = *src++) - if (b64rmap[ch] != b64rmap_space) - break; - /* Make sure there is another trailing = sign. */ - if (ch != Pad64) - return (-1); - ch = *src++; /* Skip the = */ - /* Fall through to "single trailing =" case. */ - /* FALLTHROUGH */ - - case 3: /* Valid, means two bytes of info */ - /* - * We know this char is an =. Is there anything but - * whitespace after it? - */ - for ((void)NULL; ch != '\0'; ch = *src++) - if (b64rmap[ch] != b64rmap_space) - return (-1); - - /* - * Now make sure for cases 2 and 3 that the "extra" - * bits that slopped past the last full byte were - * zeros. If we don't check them, they become a - * subliminal channel. - */ - if (target[tarindex] != 0) - return (-1); - } - } else { - /* - * We ended by seeing the end of the string. Make sure we - * have no partial bytes lying around. - */ - if (state != 0) - return (-1); - } - - return (tarindex); -} - - -static int -b64_pton_len(char const *src) -{ - int tarindex, state, ch; - uint8_t ofs; - - state = 0; - tarindex = 0; - - while (1) - { - ch = *src++; - ofs = b64rmap[ch]; - - if (ofs >= b64rmap_special) { - /* Ignore whitespaces */ - if (ofs == b64rmap_space) - continue; - /* End of base64 characters */ - if (ofs == b64rmap_end) - break; - /* A non-base64 character. */ - return (-1); - } - - switch (state) { - case 0: - state = 1; - break; - case 1: - tarindex++; - state = 2; - break; - case 2: - tarindex++; - state = 3; - break; - case 3: - tarindex++; - state = 0; - break; - default: - abort(); - } - } - - /* - * We are done decoding Base-64 chars. Let's see if we ended - * on a byte boundary, and/or with erroneous trailing characters. - */ - - if (ch == Pad64) { /* We got a pad char. */ - ch = *src++; /* Skip it, get next. */ - switch (state) { - case 0: /* Invalid = in first position */ - case 1: /* Invalid = in second position */ - return (-1); - - case 2: /* Valid, means one byte of info */ - /* Skip any number of spaces. */ - for ((void)NULL; ch != '\0'; ch = *src++) - if (b64rmap[ch] != b64rmap_space) - break; - /* Make sure there is another trailing = sign. */ - if (ch != Pad64) - return (-1); - ch = *src++; /* Skip the = */ - /* Fall through to "single trailing =" case. */ - /* FALLTHROUGH */ - - case 3: /* Valid, means two bytes of info */ - /* - * We know this char is an =. Is there anything but - * whitespace after it? - */ - for ((void)NULL; ch != '\0'; ch = *src++) - if (b64rmap[ch] != b64rmap_space) - return (-1); - - } - } else { - /* - * We ended by seeing the end of the string. Make sure we - * have no partial bytes lying around. - */ - if (state != 0) - return (-1); - } - - return (tarindex); -} - - -int -local_b64_pton(char const *src, uint8_t *target, size_t targsize) -{ - if (!b64rmap_initialized) - b64_initialize_rmap (); - - if (target) - return b64_pton_do (src, target, targsize); - else - return b64_pton_len (src); -}