<feed xmlns='http://www.w3.org/2005/Atom'>
<title>apt/methods/http.cc, branch 2.9.18</title>
<subtitle>Debians commandline package manager</subtitle>
<id>https://git.kalnischkies.de/apt/atom?h=2.9.18</id>
<link rel='self' href='https://git.kalnischkies.de/apt/atom?h=2.9.18'/>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/'/>
<updated>2024-11-22T12:13:25Z</updated>
<entry>
<title>Tag hidden acquire classes as final for devirtualization</title>
<updated>2024-11-22T12:13:25Z</updated>
<author>
<name>David Kalnischkies</name>
<email>david@kalnischkies.de</email>
</author>
<published>2024-11-19T22:42:44Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=8c760266c8c736bff62055c008ab74d78f3ed82a'/>
<id>urn:sha1:8c760266c8c736bff62055c008ab74d78f3ed82a</id>
<content type='text'>
gcc reports `warning: Declaring type ‘class X’ final would
enable devirtualization of Y calls [-Wsuggest-final-types]`.
Not that this would massively improve performance, but it
shouldn't hurt telling the compiler what is obvious for a human.
</content>
</entry>
<entry>
<title>methods/http.cc: APT::StringView -&gt; std::string_view</title>
<updated>2024-11-12T19:36:20Z</updated>
<author>
<name>наб</name>
<email>nabijaczleweli@nabijaczleweli.xyz</email>
</author>
<published>2024-11-12T18:50:56Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=b430a53e45b6d676142af7da78564de3bd97ef5f'/>
<id>urn:sha1:b430a53e45b6d676142af7da78564de3bd97ef5f</id>
<content type='text'>
</content>
</entry>
<entry>
<title>Support building without gnutls</title>
<updated>2024-03-03T07:23:51Z</updated>
<author>
<name>Steve Langasek</name>
<email>steve.langasek@canonical.com</email>
</author>
<published>2024-03-03T07:10:14Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=9044806c2adc6118399349c70a6c5746cedcc374'/>
<id>urn:sha1:9044806c2adc6118399349c70a6c5746cedcc374</id>
<content type='text'>
Once in a generation, it may be necessary to bootstrap apt in an
environment where gnutls is not yet available.  This makes gnutls
support in apt optional.

You may also want a configure flag to force gnutls to be required from
outside the buildsystem (e.g. debian/rules).
</content>
</entry>
<entry>
<title>Modernize standard library includes</title>
<updated>2024-02-20T12:49:04Z</updated>
<author>
<name>Julian Andres Klode</name>
<email>julian.klode@canonical.com</email>
</author>
<published>2024-02-20T12:43:08Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=40a75722c43ae24cb9a99d6730a3b25b65819c49'/>
<id>urn:sha1:40a75722c43ae24cb9a99d6730a3b25b65819c49</id>
<content type='text'>
This was automated with sed and git-clang-format, and then I had to
fix up the top of policy.cc by hand as git-clang-format accidentally
indented it by two spaces.
</content>
</entry>
<entry>
<title>Ignore return of .c_str() in preemptive call for signal handler</title>
<updated>2023-01-29T12:59:30Z</updated>
<author>
<name>David Kalnischkies</name>
<email>david@kalnischkies.de</email>
</author>
<published>2023-01-29T12:54:02Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=0ac3afe29cfc71c657853f06961c6c8ba9c09e5c'/>
<id>urn:sha1:0ac3afe29cfc71c657853f06961c6c8ba9c09e5c</id>
<content type='text'>
Reported-By: gcc-13 -Wunused-result
Gbp-Dch: Ignore
</content>
</entry>
<entry>
<title>Use https config on https proxies for http servers</title>
<updated>2021-09-13T14:09:19Z</updated>
<author>
<name>David Kalnischkies</name>
<email>david@kalnischkies.de</email>
</author>
<published>2021-09-12T22:54:38Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=4e04cbafe7db326b52ee650a4f4ccc3444da6890'/>
<id>urn:sha1:4e04cbafe7db326b52ee650a4f4ccc3444da6890</id>
<content type='text'>
The settings used for unwrapping TLS connections depend on the access
and hostname we connect to more than what we eventually unwrap. The
bugreport mentions CaInfo, but all other https-settings should also
apply (regardless of generic or hostname specific) to an https proxy,
even if the connection we proxy through it is http-only.

Closes: #990555
</content>
</entry>
<entry>
<title>Implement encoded URI handling in all methods</title>
<updated>2020-12-18T18:31:19Z</updated>
<author>
<name>David Kalnischkies</name>
<email>david@kalnischkies.de</email>
</author>
<published>2020-07-09T22:02:25Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=97d6c3b2d05fe0d965657197adf56cc78f9edf81'/>
<id>urn:sha1:97d6c3b2d05fe0d965657197adf56cc78f9edf81</id>
<content type='text'>
Every method opts in to getting the encoded URI passed along while
keeping compat in case we are operated by an older acquire system.

Effectively this is just a change for the http-based methods as the
others just decode the URI as they work with files directly.
</content>
</entry>
<entry>
<title>Rewrite HttpServerState::Die()</title>
<updated>2020-08-11T11:42:41Z</updated>
<author>
<name>Julian Andres Klode</name>
<email>julian.klode@canonical.com</email>
</author>
<published>2020-08-11T11:09:14Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=8b35e2a3dd7b863639a8909fa2361ed4fd217bc3'/>
<id>urn:sha1:8b35e2a3dd7b863639a8909fa2361ed4fd217bc3</id>
<content type='text'>
The old code was fairly confusing, and contradictory. Notably, the
second `if` also only applied to the Data state, whereas we already
terminated the Data state earlier. This was bad.

The else fallback applied in three cases:

(1) We reached our limit
(2) We are Persistent
(3) We are headers

Now, it always failed as a transient error if it had
nothing left in the buffer. BUT: Nothing left in the buffer
is the correct thing to happen if we were fetching content.

Checking all combinations for the flags, we can compare the results
of Die() between 2.1.7 - the last "known-acceptable-ish" version
and this version:
                                2.1.7           this
Data !Persist !Space !Limit     OK (A)           OK
Data !Persist !Space Limit      OK (A)           OK
Data !Persist Space !Limit      OK (C)           OK
Data !Persist Space Limit       OK               OK

Data Persist !Space !Limit      ERR              ERR          *
Data Persist !Space Limit       OK (B)           OK
Data Persist Space !Limit       ERR              ERR
Data Persist Space Limit        OK               OK

=&gt; Data connections are OK if they have not reached their limit,
   or are persistent (in which case they'll probably be chunked)

Header !Persist !Space !Limit   ERR              ERR
Header !Persist !Space Limit    ERR              ERR
Header !Persist Space !Limit    OK               OK
Header !Persist Space Limit     OK               OK
Header Persist !Space !Limit    ERR              ERR
Header Persist !Space Limit     ERR              ERR
Header Persist Space !Limit     OK               OK
Header Persist Space Limit      OK               OK

=&gt; Common scheme here is that header connections are fine if they have
   read something into the input buffer (Space). The rest does not matter.

(A) Non-persistent connections with !space always enter the else clause, hence  success
(B) no Space means we enter the if/else, we go with else because IsLimit(), and we succeed because we don't have space
(C) Having space we do enter the while (WriteSpace()) loop, but we never reach IsLimit(),
    hence we fall through. Given that our connection is not persistent, we fall through to the
    else case, and there we win because we have data left to write.
</content>
</entry>
<entry>
<title>http: Fully flush local file both before/after server read</title>
<updated>2020-08-11T11:09:04Z</updated>
<author>
<name>Julian Andres Klode</name>
<email>julian.klode@canonical.com</email>
</author>
<published>2020-08-11T08:55:09Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=73780d7f664a4ea1da55527d726b4c9c7753f1fb'/>
<id>urn:sha1:73780d7f664a4ea1da55527d726b4c9c7753f1fb</id>
<content type='text'>
We do not want to end up in a code path while reading content
from the server where we have local data left to write, which
can happen if a previous read included both headers and content.

Restructure Flush() to accept a new argument to allow incomplete
flushs (which do not match our limit), so that it can flush as
far as possible, and modify Go() and use that before and after
reading from the server.
</content>
</entry>
<entry>
<title>http: Do not use non-blocking local I/O</title>
<updated>2020-08-11T11:09:04Z</updated>
<author>
<name>Julian Andres Klode</name>
<email>julian.klode@canonical.com</email>
</author>
<published>2020-08-11T09:42:15Z</published>
<link rel='alternate' type='text/html' href='https://git.kalnischkies.de/apt/commit/?id=13ab2317451931f055855f1aeaec6c8b28b14ce2'/>
<id>urn:sha1:13ab2317451931f055855f1aeaec6c8b28b14ce2</id>
<content type='text'>
This causes some more issues, really.
</content>
</entry>
</feed>
