[new port] print/miktex: cross-platform implementation of TeX/LaTeX and related programs

[arrowd]

Summary

Open problems:

• Not sure what to put into LICENSE var. MiKTeX COPYING.md file states MiKTeX has neither a single copyright holder nor a single license covering its entire contents, since it is a collection of many independent packages.
• To actually use installed package, user have to run miktexsetup finish, which would install additional files into ~/bin. Running this command as root would install into /usr/local/bin. There is no way to override these directories until https://github.com/MiKTeX/miktex/issues/195 is fixed.

[rigoletto]

Hello.

I've updated to 2.9.6975, added some OPTIONS, and shut portlint. There are more OPTIONS opportunities like INSTALL_MIKTEX_HEADERS (fail to build with some Linux file missing) and WITH_LUA54TEX (lua54 is not in ports yet).

You could avail adding OPTIONS to LINK_EVERYTHING_STATICALLY and INSTALL_STATIC_LIBRARIES. :-)

[EDITED]
https://termbin.com/ott7
[EDITED]

The only downside of MiKTex would be the necessity to modify bsd.tex.mk in order to avoid Tex-Live ports installed for ports with USE_TEX.

Thank you! \o/

[tcberner]

print/miktex/Makefile

19 ↗

(On Diff #53034)

^ when in doubt, leave it out :D

40 ↗

(On Diff #53034)

^ I would prefer

USE_QT= core concurrent gui printsupport script scripttools uitools xml \
        buildtools_build qmake_build

print/miktex/pkg-plist

194 ↗

(On Diff #53034)

^ these probably should not use %%DATADIR%%

[rigoletto]

From the Handbook:

LICENSE= UNKNOWN
LICENSE_NAME= unknown
LICENSE_TEXT= This program is NOT in public domain. It can be freely distributed for non-commercial purposes only.
LICENSE_PERMS= dist-mirror no-dist-sell pkg-mirror no-pkg-sell auto-accept

[mat]

print/miktex/pkg-plist

192 ↗

(On Diff #53034)

DATADIR is a directory which means, it must always be %%DATADIR%%/.

[rigoletto]

There is a problem with luatex:

FATAL error while preloading lua module luatex_url_lua_open(L)Process 45975 stopped
* thread #1, name = 'miktex-luatex', stop reason = signal SIGABRT
    frame #0: 0x00000008011ac17a libc.so.7`__sys_thr_kill at thr_kill.S:3
   1   	#include "compat.h"
   2   	#include "SYS.h"
-> 3   	RSYSCALL(thr_kill)
   4   		.section .note.GNU-stack,"",%progbits

[arrowd]

• Update to 2.9.6980.
• Incorporate changes by @rigoletto
• Address comments

miktex-luatex requires net/luasocket for Lua 5.3, but there are no FLAVORS for Lua, so I can't depend on that. @mat, any thoughts how to workaround it?

[mat]

print/miktex/Makefile

74–79 ↗

(On Diff #54067)

Please use options helpers.

[arrowd]

• Use option helpers for UIQT.

[arrowd]

The question about net/luasocket stays open.

[mat]

print/miktex/Makefile

20 ↗

(On Diff #55829)

Please remove this. poudriere will build this without a problem, it has auto-accept. If you are testing a restricted port, sipmly add DISABLE_LICENSES=yes the make.conf.

[arrowd]

• Update to 7000, remove license hack.

[arrowd]

So, I need net/luasocket for LUA 5.3. Should I open a PR requesting lua flavorization, or just create a net/luasocket53?

[mat]

In D18903#433043, @arrowd wrote:

So, I need net/luasocket for LUA 5.3. Should I open a PR requesting lua flavorization, or just create a net/luasocket53?

I do not think anyone has plans to write flavors for USES=lua so openning a PR requesting it would probably be pointless.

[arrowd]

In D18903#433045, @mat wrote:

I do not think anyone has plans to write flavors for USES=lua so openning a PR requesting it would probably be pointless.

I need a way forward. Should I start looking into flavorizing LUA, switching everything to lua 5.3 or creating a net/luasocket53?

[mat]

In D18903#433214, @arrowd wrote:

In D18903#433045, @mat wrote:

I do not think anyone has plans to write flavors for USES=lua so openning a PR requesting it would probably be pointless.

I need a way forward. Should I start looking into flavorizing LUA, switching everything to lua 5.3 or creating a net/luasocket53?

I have no idea if having flavors for lua makes sense. I think the best way to move forward would be a luasocket53 port for now.

[arrowd]

• Properly install symlinks.

[arrowd]

It turned out that miktex uses internal LUA and luasocket, so the new port isn't needed. Bad news is that I cannot figure out where the error comes from. Any help with debugging this would be welcome.

[arrowd]

Upstream has fixed the LUA bug and it will be present in the next release.

[arrowd]

• Update to 2.9.7140.

[arrowd]

The LUA bug have not been fixed and upstream seem to be reluctant to fix it.

[arrowd]

• Workaround LUA problem by using GCC to compile the port.

[arrowd]

The port is ready to be committed. I'll wait for couple of days in case someone wants to review it.

[arrowd]

It seems, it still would be skipped by poudriere due to

Ignored: License NONE needs confirmation, but BATCH is defined

If I want miktex to be present in FreeBSD packages, what should I do?

[arrowd]

• Refresh distfiles and host them on LOCAL, as they tend to change over time.

[arrowd]

• Disable UIQT and SYNCTEX options, as these are causing compilation failures with GCC. Fix plist for DOCS and CONTEXT options.

[arrowd]

Too many bugs, postponing this for later.

[arrowd]

• Update to 20.10. The ports seem to be working now.

[arrowd]

• Update to 20.11. The ports seem to be working now.
• Properly handle all OPTIONS.
• Add pkg-message.

[arrowd]

I have battle-tested this port and it works for me. Any last comments before I commit it?

head/print/Makefile

case ETHERTYPE_IP:
                 if (mbuf->m_len < ehdrlen + sizeof(struct ip)) {
                         mbuf = m_pullup(mbuf, ehdrlen + sizeof(struct ip));
                         sq->snd_buff[qentry].mbuf = mbuf;
                         if (mbuf == NULL)
                                 return (ENOBUFS);
                 }
 
                 ip = (struct ip *)(mbuf->m_data + ehdrlen);
-                ip->ip_sum = 0;
                 iphlen = ip->ip_hl << 2;
                 poff = ehdrlen + iphlen;
 
                 if (mbuf->m_pkthdr.csum_flags != 0) {
                         hdr->csum_l3 = 1; /* Enable IP csum calculation */
                         switch (ip->ip_p) {
                         case IPPROTO_TCP:
                                 if ((mbuf->m_pkthdr.csum_flags & CSUM_TCP) == 0)
nicvf_get_rcv_mbuf(struct nicvf *nic, struct cqe_rx_t *cqe_rx)
         if (__predict_true(mbuf != NULL)) {
                 m_fixhdr(mbuf);
                 mbuf->m_pkthdr.flowid = cqe_rx->rq_idx;
                 M_HASHTYPE_SET(mbuf, M_HASHTYPE_OPAQUE);
                 if (__predict_true((if_getcapenable(nic->ifp) & IFCAP_RXCSUM) != 0)) {
                         /*
                          * HW by default verifies IP & TCP/UDP/SCTP checksums
                          */
-
-                        /* XXX: Do we need to include IP with options too? */
-                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4 ||
-                            cqe_rx->l3_type == L3TYPE_IPV6)) {
+                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4)) {
                                 mbuf->m_pkthdr.csum_flags =
                                     (CSUM_IP_CHECKED | CSUM_IP_VALID);
                         }
-                        if (cqe_rx->l4_type == L4TYPE_TCP ||
-                            cqe_rx->l4_type == L4TYPE_UDP ||
-                            cqe_rx->l4_type == L4TYPE_SCTP) {
+
+                        switch (cqe_rx->l4_type) {
+                        case L4TYPE_UDP:
+                        case L4TYPE_TCP: /* fall through */
                                 mbuf->m_pkthdr.csum_flags |=
                                     (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
-                                mbuf->m_pkthdr.csum_data = htons(0xffff);
+                                mbuf->m_pkthdr.csum_data = 0xffff;
+                                break;
+                        case L4TYPE_SCTP:
+                                mbuf->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
+                                break;
+                        default:
+                                break;
                         }
                 }
         }
 
         return (mbuf);
 }
 
 /* Enable interrupt */

head/print/miktex/Makefile

case ETHERTYPE_IP:
                 if (mbuf->m_len < ehdrlen + sizeof(struct ip)) {
                         mbuf = m_pullup(mbuf, ehdrlen + sizeof(struct ip));
                         sq->snd_buff[qentry].mbuf = mbuf;
                         if (mbuf == NULL)
                                 return (ENOBUFS);
                 }
 
                 ip = (struct ip *)(mbuf->m_data + ehdrlen);
-                ip->ip_sum = 0;
                 iphlen = ip->ip_hl << 2;
                 poff = ehdrlen + iphlen;
 
                 if (mbuf->m_pkthdr.csum_flags != 0) {
                         hdr->csum_l3 = 1; /* Enable IP csum calculation */
                         switch (ip->ip_p) {
                         case IPPROTO_TCP:
                                 if ((mbuf->m_pkthdr.csum_flags & CSUM_TCP) == 0)
nicvf_get_rcv_mbuf(struct nicvf *nic, struct cqe_rx_t *cqe_rx)
         if (__predict_true(mbuf != NULL)) {
                 m_fixhdr(mbuf);
                 mbuf->m_pkthdr.flowid = cqe_rx->rq_idx;
                 M_HASHTYPE_SET(mbuf, M_HASHTYPE_OPAQUE);
                 if (__predict_true((if_getcapenable(nic->ifp) & IFCAP_RXCSUM) != 0)) {
                         /*
                          * HW by default verifies IP & TCP/UDP/SCTP checksums
                          */
-
-                        /* XXX: Do we need to include IP with options too? */
-                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4 ||
-                            cqe_rx->l3_type == L3TYPE_IPV6)) {
+                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4)) {
                                 mbuf->m_pkthdr.csum_flags =
                                     (CSUM_IP_CHECKED | CSUM_IP_VALID);
                         }
-                        if (cqe_rx->l4_type == L4TYPE_TCP ||
-                            cqe_rx->l4_type == L4TYPE_UDP ||
-                            cqe_rx->l4_type == L4TYPE_SCTP) {
+
+                        switch (cqe_rx->l4_type) {
+                        case L4TYPE_UDP:
+                        case L4TYPE_TCP: /* fall through */
                                 mbuf->m_pkthdr.csum_flags |=
                                     (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
-                                mbuf->m_pkthdr.csum_data = htons(0xffff);
+                                mbuf->m_pkthdr.csum_data = 0xffff;
+                                break;
+                        case L4TYPE_SCTP:
+                                mbuf->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
+                                break;
+                        default:
+                                break;
                         }
                 }
         }
 
         return (mbuf);
 }
 
 /* Enable interrupt */

head/print/miktex/distinfo

case ETHERTYPE_IP:
                 if (mbuf->m_len < ehdrlen + sizeof(struct ip)) {
                         mbuf = m_pullup(mbuf, ehdrlen + sizeof(struct ip));
                         sq->snd_buff[qentry].mbuf = mbuf;
                         if (mbuf == NULL)
                                 return (ENOBUFS);
                 }
 
                 ip = (struct ip *)(mbuf->m_data + ehdrlen);
-                ip->ip_sum = 0;
                 iphlen = ip->ip_hl << 2;
                 poff = ehdrlen + iphlen;
 
                 if (mbuf->m_pkthdr.csum_flags != 0) {
                         hdr->csum_l3 = 1; /* Enable IP csum calculation */
                         switch (ip->ip_p) {
                         case IPPROTO_TCP:
                                 if ((mbuf->m_pkthdr.csum_flags & CSUM_TCP) == 0)
nicvf_get_rcv_mbuf(struct nicvf *nic, struct cqe_rx_t *cqe_rx)
         if (__predict_true(mbuf != NULL)) {
                 m_fixhdr(mbuf);
                 mbuf->m_pkthdr.flowid = cqe_rx->rq_idx;
                 M_HASHTYPE_SET(mbuf, M_HASHTYPE_OPAQUE);
                 if (__predict_true((if_getcapenable(nic->ifp) & IFCAP_RXCSUM) != 0)) {
                         /*
                          * HW by default verifies IP & TCP/UDP/SCTP checksums
                          */
-
-                        /* XXX: Do we need to include IP with options too? */
-                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4 ||
-                            cqe_rx->l3_type == L3TYPE_IPV6)) {
+                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4)) {
                                 mbuf->m_pkthdr.csum_flags =
                                     (CSUM_IP_CHECKED | CSUM_IP_VALID);
                         }
-                        if (cqe_rx->l4_type == L4TYPE_TCP ||
-                            cqe_rx->l4_type == L4TYPE_UDP ||
-                            cqe_rx->l4_type == L4TYPE_SCTP) {
+
+                        switch (cqe_rx->l4_type) {
+                        case L4TYPE_UDP:
+                        case L4TYPE_TCP: /* fall through */
                                 mbuf->m_pkthdr.csum_flags |=
                                     (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
-                                mbuf->m_pkthdr.csum_data = htons(0xffff);
+                                mbuf->m_pkthdr.csum_data = 0xffff;
+                                break;
+                        case L4TYPE_SCTP:
+                                mbuf->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
+                                break;
+                        default:
+                                break;
                         }
                 }
         }
 
         return (mbuf);
 }
 
 /* Enable interrupt */

head/print/miktex/pkg-descr

case ETHERTYPE_IP:
                 if (mbuf->m_len < ehdrlen + sizeof(struct ip)) {
                         mbuf = m_pullup(mbuf, ehdrlen + sizeof(struct ip));
                         sq->snd_buff[qentry].mbuf = mbuf;
                         if (mbuf == NULL)
                                 return (ENOBUFS);
                 }
 
                 ip = (struct ip *)(mbuf->m_data + ehdrlen);
-                ip->ip_sum = 0;
                 iphlen = ip->ip_hl << 2;
                 poff = ehdrlen + iphlen;
 
                 if (mbuf->m_pkthdr.csum_flags != 0) {
                         hdr->csum_l3 = 1; /* Enable IP csum calculation */
                         switch (ip->ip_p) {
                         case IPPROTO_TCP:
                                 if ((mbuf->m_pkthdr.csum_flags & CSUM_TCP) == 0)
nicvf_get_rcv_mbuf(struct nicvf *nic, struct cqe_rx_t *cqe_rx)
         if (__predict_true(mbuf != NULL)) {
                 m_fixhdr(mbuf);
                 mbuf->m_pkthdr.flowid = cqe_rx->rq_idx;
                 M_HASHTYPE_SET(mbuf, M_HASHTYPE_OPAQUE);
                 if (__predict_true((if_getcapenable(nic->ifp) & IFCAP_RXCSUM) != 0)) {
                         /*
                          * HW by default verifies IP & TCP/UDP/SCTP checksums
                          */
-
-                        /* XXX: Do we need to include IP with options too? */
-                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4 ||
-                            cqe_rx->l3_type == L3TYPE_IPV6)) {
+                        if (__predict_true(cqe_rx->l3_type == L3TYPE_IPV4)) {
                                 mbuf->m_pkthdr.csum_flags =
                                     (CSUM_IP_CHECKED | CSUM_IP_VALID);
                         }
-                        if (cqe_rx->l4_type == L4TYPE_TCP ||
-                            cqe_rx->l4_type == L4TYPE_UDP ||
-                            cqe_rx->l4_type == L4TYPE_SCTP) {
+
+                        switch (cqe_rx->l4_type) {
+                        case L4TYPE_UDP:
+                        case L4TYPE_TCP: /* fall through */
                                 mbuf->m_pkthdr.csum_flags |=
                                     (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
-                                mbuf->m_pkthdr.csum_data = htons(0xffff);
+                                mbuf->m_pkthdr.csum_data = 0xffff;
+                                break;
+                        case L4TYPE_SCTP:
+                                mbuf->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
+                                break;
+                        default:
+                                break;
                         }
                 }
         }
 
         return (mbuf);
 }
 
 /* Enable interrupt */