* BSecureSocket::CertificateVerificationFailed() took a BCertificate
instance by value as parameter.
BCertificate deletes internal data in its destructor. Passing an
object by value creates a copy, so the copy attempted to delete
the internal data again during its destruction.
This caused mail_daemon to crash here when it came across a failed
certificate.
* Fix: pass BCertificate object as reference.
* Instead of creating an OpenSSL context ofor each socket, use a global
one and initialize it lazily when the first SecureSocket is created
* Load the certificates from our certificate list so SSL certificates
sent by servers can be validated.
* Add a callback for signalling that certificate validation failed, the
default implementation proceeds with the connection anyway (to keep the
old behavior).
* Introduce BCertificate class, that provides some information about a
certificate. Currently it's only used by the callback mentionned above,
but it will be possible to get the leaf certificate for the connection
after it's established.
Review of the API and implementation is welcome, before I start making
use of this in HttpRequest and WebKit to allow the user to accept new
certificates.
Use standard error codes instead.
This allows using error code returned by the underlying functions
directly, and makes it possible to use strerror for debugging. So, we
can also remove StatusString() from the various *Request classes.
When calling Stop(), we expect the request thread to exit as soon as
possible. Closing the connection unlocks it from any blocking read() or
write(), avoiding some lockup situations.
* BUrlResult is back, with ContentType and Length methods.
* BHttpResult subclasses it and use HTTP header fields to implement
those
* Introduce BDataRequest for "data" URIs. These embed the data inside
the URI, either as plaintext or base64 encoded.
We can send the data directly to the output socket instead of copying it
into a BString first, at the cost of very slightly less information in
debug output.
When using the copy constructor of BNetEndpoint the socket of the
original endpoint gets dup'ed. The Accept() method later directly reset
the fSocket member of the newly created BNetEndpoint to the socket
returned by accept(). The socket dup'ed by the copy constructor was
therefore leaked.
Of course dup'ing the socket and copying the local and remote addresses
is superfluous in the accept case, as these members all get set to new
values. To reduce that overhead there is now a new private constructor
that directly gets the final socket and remote and local address.
Implement BNetworkRoster::GetRoutes() and BNetworkInterface::GetRoutes().
Also implement BNetworkInterface::GetDefaultGateway().
There is code duplication at the moment, and the api only supports IPV4.
* Remove useless dummy protocol loop in UrlRequest
* Stop HTTP requests before deleting the socket and other things the
loop may still be using
* Deletion of items from the authentication map wasn't working
* Remove some debug traces
The authentication state is stored (in a hash map, using the domain+path
as a key) in the UrlContext class. It can then be reused for multiple
requests to the same place. We also lookup stored authentications for
parent directories and stop at the first we find.
Authentication state is not stored on disk (unlike cookies), and there
can only be one for each domain+path.
This change is needed for implementing cookie persistence in Web+ using
the network kit backend.
The current implementation requires the user to unarchive the cookie
jar, then hand it over to the BUrlContext which will copy it to its own
field. This makes the code simpler, but maybe doing a complete copy
(with all the cookies) is an heavy operation and could be avoided.
* Remove the fRawData field, as handling it is too complicated (it's
not easy to have proper copy semantics on a BDataIO) and it's not used
anyway, as the listener DataReceived call is enough to get the data and
handle it.
* All the remaining fields are HTTP-only, so rename the class to
HttpResult and attach it to HttpRequest instead of UrlRequest.
CID 1108353, 1108335: memory leak.
CID 610473: unused variable.
CID 1108446, 1108433, 1108432, 1108419, 1108400, 991710, 991713, 991712,
610098, 610097, 610096, 610095: uninitialized field
CID 1108421: unused field
Change the ownership of the result for Url/HttpRequests. The request now
owns its result and you either access it by reference while the request
is live, or copy it to keep it after the request destruction. To help
with that, get BUrlResult copy constructor and assignment operator to
work.
Performance issue: copying the BUrlResult also copies the underlying
BMallocIO data. This should be shared between the BUrlResult objects to
make the copy lighter. The case of BUrlSynchronousRequest is now
particularly inefficient, with at least 2 copies needed to get at the
result.
* Now takes ownership of headers, form data and input data
* Split Set* and Adopt* methods to help with proper use of this (Set
does a copy)
* Write documentation.
* The RFC provide a regular expression for URI parsing, so just use it.
* Allows parsing URIs with missing components (no scheme or authority)
* This allows to parse relative URLs as expected
* Can also handle things such as data: or mailto:
* Also more fixes to handling of incomplete URIs, some flags weren't
always set to the right values.
This gets Windows Live Mail (or is it called Outlook?) working, with
some other fixes on WebKit side.
* With so long class names, there's no way I'm going to follow the 64
char limit on commit headlines.
* The class share the same API, so having them separate is not very
useful.
* This makes it possible to use the same listener in either synchronous
or asycnhronous mode (or both, for different requests)
* Add some error handling in NetworkCookie and don't add broken cookies
(or should I say crumbs?) to the cookie jar
* More control on the path and domain, as well as the expiration time
We now pass Opera cookie testsuite functionality tests, as well as some
of the negative tests (we even do better than curl). Not going further
right now as this works well enough for positive cases and most
security/privacy issues are fixed (cross domain and cross path cookie
setting or spying).
* This takes a relative path as a parameter, and modifies the object to
point to the given location.
* '..' is not handled yet, and will be sent as-is to the server.
* Makes it possible to follow more types of 302 redirects
In particular, I can now run the tests from Opera's testsuite
(testsuite.opera.com), which shows I have more work to do on cookie
handling.
* Some fields weren't initialized, leading to random crashes later on
* Remove the enum that was used for protocol options
* Use a single field to track the request state, instead of separate
booleans.
* The cookie jar iterator now use a BObjectList instead of a BList
* Add a convenience method to the cookie jar to add a cookie by BUrl
and raw cookie string.
* Remove some methods in BNetworkCookie that could lead to invalid
cookies (cross-domain or with no domain at all).
* Make the cookie parsing able to report errors
* Fix off-by-one error in domain cookies validation.
* Remove the BUrlRequest class, which was only delegating work to
BUrlProtocol and subclasses
* Rename BUrlProtocol to BUrlRequest, and BUrlRequestHttp to BHttpRequest
* Creating a request is now done through the BUrlProtocolRoster. For
now there is just a static MakeRequest method, this will be completed
when we get to actually allowing add-ons to provide different request
handlers.
This allows cleanup of the API for requests:
* Remove the universal SetOption method with constants, and have
dedicated setters for each protocol option.
* Setters can now have multiple parameters, for example you can give
BHTTPRequest a BDataIO and a known size
* In this case, the BHttpRequest will not use HTTP chunked transfers,
which were always used before and made most servers unhappy (tested and
failed with lighttpd, google accounts and github).
* The use of a static variable for storing the chunk size made it shared between all instances of BUrlProtoclHttp.
* Inline the function at the single place where it is used, and allocate the variable on the stack instead.
The whole receiving loop should be split into chunked and non-chunked variants to improve code readability.
* Each class has a Socket() method to retrieve the underlaying file descriptor
to be able to do the more advanced stuff, if necessary.
* A server socket is yet missing, but the rest is pretty much covered.
BNetworkRoster::{Count|GetNext|Add|Remove}PersistentNetwork() as it fits
better (thanks Philippe for the heads up).
* Implement the backend for these functions in the net_server and also move
conversion of the wireless_network based format into the settings based format
there.
* Implement removal of a network from the settings and make adding a new network
with the same name replace the old one instead of just adding multiple ones.
Might need to change this in the future depending on how we want to handle
multiple networks with the same name (i.e. distinguish based on BSSID or
similar).
* Fix apparent oversight that caused configured networks _not_ to be used in the
auto join attempt.
* Remove auto joining open networks. I've been bitten by that more than once now
because we happen to have an open network in the neighbourhood that I now
accidentally used to transfer quite a bit of (unencrypted) stuff before
noticing... In the future, one will instead have to explicitly join an open
network once and store that config. Note that the driver will actually still
auto-associate with open networks due to how things are set up currently.
Note also that the auto join will fire join requests whenever there's a
disassociation event, so you might see spurious join dialogs when the
wpa_supplicant actually just re-establishes the connection.
* Make join requests async again. Instead of waiting for a synchronous reply of
the wpa_supplicant we instead return success when the request has been sent.
While the API call might still be made synchronous again in the future, the
net_server should really not block on an external application. In the case of
the wpa_supplicant we would otherwise deadlock when using the new
*PersistentNetwork() API after a successful join, and in other cases we might
just unacceptably delay other calls.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@42816 a95241bf-73f2-0310-859d-f6bbb57e9c96
be stored by the backend in the net_server. I put it in BNetworkDevice because
that is where network enumeration is done as well, but I'm not sure that it fits
there particularly well.
Since BNetworkDevice::GetNetwork() directly interfaces with the driver and gets
the networks from scan results, such persistent networks don't yet show up in
those enumerations.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@42807 a95241bf-73f2-0310-859d-f6bbb57e9c96
in_addr_t is now in network endian again. Thanks, Philippe!
* Made SetToLoopback(), and SetToLocal() a bit more useful (although the latter
isn't implemented yet).
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40552 a95241bf-73f2-0310-859d-f6bbb57e9c96
retrieve the WLAN cipher/key configuration. Might not work perfectly yet; so
far I've only seen WPA2, and WPA networks.
* Have wlan_test show this extra info.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@39792 a95241bf-73f2-0310-859d-f6bbb57e9c96
