- Boost - lists.boost.org

[beast] Supporting ICY 200 OK
by Vinnie Falco 04 Oct '17

04 Oct '17

Bjorn brought up the point that there are some niche cases where applications do not strictly follow the HTTP message syntax for responses. Specifically, for Shoutcast(?) / Icecast mp3 servers the status-line in the response looks something like this: ICY 200 OK\r\n I have thought about ways to support this directly in Beast but I have decided against it. "ICY 200" is not HTTP according to the RFC, and trying to accommodate this use case places needless technical debt in public interfaces. However, I came up with a very simple technique to make this work with Beast by writing just a tiny bit of extra code. The solution is to implement a stream wrapper which meets the requirements of SyncReadStream[1] and/or AsyncReadStream[2] and forwards the calls to read to the "next layer" object, which will be the actual socket or ssl::stream. The implementation of the icy_stream wrapper can check to see if the first 3 bytes received from the next layer match "ICY" and if so, return a buffer to the caller which replaces those characters with "HTTP/1.1" (or "HTTP/1.0"). With this wrapper, calls to beast::http::read or beast::http::async_read can parse the custom response as a regular HTTP message. The wrapper can embed state information to inform the caller if the "ICY" string was not received. The declaration for such a wrapper might look like this: template<class NextLayer> class icy_stream; Usage for the wrapper: asio::ip::tcp::socket sock{ios}; icy_stream<asio::ip::tcp::socket&> stream{sock}; beast::http::response<beast::http::empty_body> res; beast::multi_buffer buffer; beast::http::read(stream, buffer, res); This technique may of course be generalized to support any desired similar but non-standard HTTP requests or responses in a fashion that is completely transparent to Beast. Thanks [1] <http://www.boost.org/doc/libs/1_65_1/doc/html/boost_asio/reference/SyncRead…> [2] <http://www.boost.org/doc/libs/1_65_1/doc/html/boost_asio/reference/AsyncRea…>

2 4

Re: [boost] [beast] A Networking-TS version of Boost.Asio and Boost.Beast is here!
by Vinnie Falco 04 Oct '17

04 Oct '17

On Tue, Oct 3, 2017 at 9:40 AM, Vinnie Falco <vinnie.falco(a)gmail.com> wrote: > My preview of Boost.Asio version 1.66.0 is here: > > <https://github.com/vinniefalco/boost.asio/commits/net-ts> Upon re-reading the message I realize that it might be confusing, so to clarify - this is NOT an "official" version of Boost.Asio it is just an experimental branch of what Boost.Asio might look like soon, for anyone who wants to try out the latest stand-alone Asio features in the Boost.Asio context. Thanks

2 5

Boost.Buffers, a new library from the makers of Beast!
by Vinnie Falco 03 Oct '17

03 Oct '17

During the formal review of Beast, desires were expressed to use components like the HTTP parser and serializer independently from the rest of the library. The sticking point was the abstraction used to represent a range of non-owning buffers. In particular, Asio imposes certain concrete type requirements in its ConstBufferSequence and MutableBufferSequence concepts. It would seem there is significant interest in making some components of Beast modular, in their own libraries. The main feature of these components would be that they should not require Boost.Asio. Unfortunately, the way Asio's concepts are defined this is not possible. Two solutions present themselves: 1. Create a new buffer sequence concept which retains all the features of Asio's concepts but does not require the concrete types. While this is possible it would create a significant complication. Interfaces which use the new concept would require some kind of adapter at every call site that tries to use a traditional Asio style interface. 2. Create a new library which uses conditional compilation to either include just the Asio header files which fulfill the needs for interacting with buffer sequence concepts, or provide the declarations directly from a copy of the Asio sources. The solution used in Boost.Buffers (a new library I am considering proposing) is choice number two. Someone who wants to create a new library ("Foo") that does no network I/O but wants to interoperate with Asio buffer concepts merely need to do the following #include <boost/buffers.asio.hpp> and then, in their build script for the tests and examples, set: #define BOOST_NET_BUFFER_NO_ASIO 1 This works because Boost.Buffers contains copies of all the necessary header files to work with buffer sequences, and JUST those header files. All of Boost.Asio is not necessary: <https://github.com/vinniefalco/buffers/blob/30ef7031ec0909972a720c0cdd8d6c6…> Now if someone wants to use library Foo they will also be getting a dependency on Boost.Buffers. If that user doesn't need Asio, then they will also set the macro to 1 in their build script. However. if that user wants to use Asio in their program or library, they just set #define BOOST_NET_BUFFER_NO_ASIO 0 and now Boost.Buffers will simply include the relevant Asio header files. This library will allow the creation of new libraries which use Asio buffer concepts, but do not require all of Boost.Asio as a dependency, as well as all the things that Boost.Asio is dependent on, which is non-trivial as can be seen here: <https://github.com/boostorg/beast/blob/develop/.travis.yml#L140> I would like feedback on this library before I move forward with it, as you can imagine it has some controversial aspects to it. Boost.Buffers is here: <https://github.com/vinniefalco/buffers> Thanks

1 0

[beast] The Networking-TS version of Boost.Asio and Boost.Beast is here!
by Vinnie Falco 03 Oct '17

03 Oct '17

I have taken the tip of standalone Asio, from: <https://github.com/chriskohlhoff/asio/commits/asio-1-10-branch> and applied this "boostify.pl" script: <https://github.com/chriskohlhoff/asio/blob/asio-1-10-branch/asio/boostify.pl> plus a bit of manual fixing, to produce a new branch of Boost.Asio which is up-to-date with respect to the stand-alone Asio. This means you can have access to the Networking-TS changes that will be introduced in Boost.Asio (according to the author, this will be in Boost 1.66.0). My preview of Boost.Asio version 1.66.0 is here: <https://github.com/vinniefalco/boost.asio/commits/net-ts> Beast has been ported to this version of Asio, you can try it here: <https://github.com/vinniefalco/beast/commits/net-ts> When Boost.Asio is updated for 1.66.0 to bring it in-line with the standalone Asio (which supports Networking-TS), Beast will simultaneously be updated. Hopefully this will all be done in time for 1.66.0, so that users of the debut version of Beast will have the latest interfaces available for their use. Thanks!

1 0

Modularizing explicit-failures-markup.xml
by Daniel James 03 Oct '17

03 Oct '17

Hi, I'm looking into implementing a mechanism for updating explicit-failures-markup.xml without updating the super project. My basic idea is that modules can have a 'status/explicit-failures-markup.xml' file, and I'll write a script to update the super project file from modules. It will have the same format as the super project file, so can just copy and paste the relevant parts into your module. Does that sound okay? It might be better if the regression scripts handled this themselves, but I'm not sure if anyone would be available to implement that. Daniel

6 12

[asio] Verify SSL certificates using the OS-specific certificate store
by Vinnie Falco 01 Oct '17

01 Oct '17

My understanding of boost::asio::ssl::context is that it is just a small wrapper around OpenSSL. You can set default verify paths, but that assumes the certificates are in a particular directory which they almost never are. For example they might be in some OS-specific type of database which need system calls to access. If a program wants to use the native operating system facilities for verifying certificates, then I believe significant additional code is needed. Is this correct? I am interested in writing a simple function object which will validate a hostname and its accompanying certificate against the operating-system-dependent certificate authorities. Is there some code somewhere that does this? Any resources that I can be pointed to would be of immense value. Thanks

2 1

Re: [boost] [beast] Supporting ICY 200 OK
by Bjorn Reese 01 Oct '17

01 Oct '17

On 10/02/2017 12:06 AM, Vinnie Falco wrote: > However, I came up with a very simple technique to make this work with > Beast by writing just a tiny bit of extra code. The solution is to > implement a stream wrapper which meets the requirements of > SyncReadStream[1] and/or AsyncReadStream[2] and forwards the calls to > read to the "next layer" object, which will be the actual socket or > ssl::stream. Sounds like a good solution.

1 0

[review] The review period of Boost.DoubleEnded has been extended with one week. Now ends 7th of October.
by Thorsten Ottosen 28 Sep '17

28 Sep '17

Dear users and members of Boost, People have been requesting extra time for the review of Boost.DoubleEnded. We therefore continue one week extra, so the final date will be October the 7th. kind regards Thorsten Original review announcement ------------------------------------------ I'm proud to announce that the formal review of Benedek Thaler's Boost.DoubleEnded library starts today, September 21, and runs through September 30. This library is the result of Benedek's participation in Google Summer of Code 2015. The library may be downloaded from https://github.com/erenon/double_ended and the documentation may be found here: http://erenon.hu/double_ended/ Anyone is welcome to post a review and/or take part in subsequent discussions (see below for review guidelines). Introduction ------------ This is a container library that provides two containers: A. boost::devector B. boost::batch_deque Both containers provides efficient push_front and push_back operations, hence the name DoubleEnded. The boost::devector class can be seen as an extension of std::vector with efficient support for push_front (so boost::devector provides contiguous storage). In addition, it provides a customizable small buffer optimization like boost::small_vector(*). It furthermore allows for customization of the growth factor such that the user can decide if a reallocation should allocate 1.5 or 2 or whatever more memory. And finally it provides new functionality that does not exist in normal vector implementations -- this functionality allow the class to excel in performance in certain situations like serialization or transfer of data from sources that require a preallocated buffer. The boost::batch_deque is similar to std::deque, but with two important twists. Like std::deque, it provides reference stability when calling push_front/push_back. Reference stability is crucial for programs that uses intrusive containers e.g. using Boost.Intrusive (**). boost::batch_deque has the following main advantages: 1. It allows the user to specify the segment size 2. It allows for external iteration over the segments Taken together, they provide a very efficient and flexible basis for intrusive containers. Access to the segments also increases performance for tasks such as serialization. Finally, boost::batch_deque may be seen as an efficient alternative to std::vector if you want to replace a percent-wise memory overhead with a constant memory overhead and have no need for contiguous storage. Review guidelines ----------------- Please provide in your review whatever information you think is valuable to understand your final choice of ACCEPT or REJECT including Boost.DoubleEnded as a Boost library. Please be explicit about your decision. Some other questions you might want to consider answering: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With which compiler(s)? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? - Are you knowledgeable about the problem domain? More information about the Boost Formal Review Process can be found here: http://www.boost.org/community/reviews.html Kind regards Thorsten, Review manager (*) boost::small_vector: https://tinyurl.com/ycslp4ot (**) http://www.boost.org/doc/libs/1_64_0/doc/html/intrusive.html -- Best regards, Thorsten Jørgen Ottosen, Ph.D. Director of Research +45 23308797 Dezide (www.dezide.com)

1 0

[admin] Turning on Issues tab on Github for Boost libraries
by Edward Diener 28 Sep '17

28 Sep '17

Can we not have some resolution from an administrator about turning on the Issues tab in Github for Boost libraries ? There are two 'admin' issues regarding this and, since it should be a quick job for an administrator to implement this, I would really prefer not to wait for a long time for this to get done. Just now I had a "bogus" PR for iostreams, which I rejected, and the explanation from the person who created the PR was that the PR was "created" because there was no Issue tab for the library and he was only trying to create an Issue to be looked at. There is absolutely no logical reason that I can think of why the Issue tab on Github cannot be turned on for Boost libraries, to benefit end-users.

3 3

Re: [boost] [ANN] Boost.UI - a new C++ GUI library
by Kolya Kosenko 28 Sep '17

28 Sep '17

On 09/28/2017 03:02 PM, Stefan Seefeld via Boost wrote: >> - uses native system-provided widgets > > what widgets do you consider "system-provided" ? What backends do you > bind to on the different platforms, and can those bindings be changed ? Native system-provided widgets means widgets from toolkits GTK+, Qt, Windows Controls, Cocoa etc. >> - compatible with other Boost libraries > > What does that mean ? Boost.Geometry and Boost.Polygon could be used with Boost.UI coordinates, Boost.Chrono - boost::ui::on_timeout() function, Boost.Date_Time library are used in date and time pickers etc. > I'd be interested in some high-level documentation explaining the basic > programming and execution model of the API. You can ask for implementation details here. Documentation explains only API. > For example, how are events > handled and how are they bound to particular actions ? Library subscribes to event handlers in native toolkit. When user press button, native event handler eventually calls Boost.UI event handler. > Are programs > inherently multi-threaded or single-threaded (e.g., does the main event > loop run in its own thread) ? There is main GUI thread and you should call GUI functions from other your own threads using boost::ui::call_async() function. Boost.UI library (like all other C++ GUI libraries) aren't thread safe because native toolkits are not thread safe. > Is your library mostly just a (thin) layer over existing > platform-specific GUI libraries, or does it reimplement a lot of the > logic itself ? Boost.UI is a rather thin layer with C++11/Boost support. > (And what is that cryptic "ui_main()" function ? :-) ) ui_main() function call required for GUI initialization, deinitialization, cleanup. It is required for underlying toolkits. Actually you can call some functions directly from main() function, but it is at your own risk. Regards, Kolya.

2 4