limox - The Linux on mobile XMPP (LimoX) client

Age	Commit message (Collapse)	Author
2023-07-09	Pass roster result to limox struct	xengineering
	This is needed to display the roster in the context of GUI.
2023-07-06	Apply go fmt	xengineering

2023-07-06	Implement roster result handling	xengineering
	This completes the roster get / result cycle which is needed for a MVP.
2023-07-06	Implement roster get request	xengineering
	This asks the server for the roster / contact list for the current account.
2023-07-06	Use different IQ struct for RX and TX	xengineering
	It is quite tricky to write structs with correct XML struct tags which are suitable for RX and TX because in RX structs all possible fields have to be addressed and in TX some have to be hidden depending on the use case.
2023-07-05	Migrate bind sending to new generic iq struct	xengineering
	This makes the code way less complex.
2023-07-05	Migrate bind receive to new iq struct	xengineering

2023-07-05	Add new generic iq struct	xengineering
	This will cover all iq use cases with optional arguments and sub-elements.
2023-07-05	Move bind logic to new xmpp/iq.go	xengineering
	The bind request / response works with IQ stanzas. Because of the way encoding and decoding is done with LimoX / the Go standard library it makes sense to group IQ-based logic in a separat file since the struct for IQs will be there.
2023-07-05	Apply go fmt	xengineering

2023-07-05	Implement echo bot	xengineering
	This demonstrates the full one-to-one chat message backend without the need to implement the GUI.
2023-07-04	Implement (chat) message receiving backend	xengineering
	This sets a handler and the routing up to be able to log chat messages with body and sender reference. This can later be used for the GUI.
2023-07-04	Apply go fmt	xengineering

2023-07-04	Remove unused code	xengineering

2023-07-04	Re-implement resource binding and presence	xengineering
	This was removed for refactoring.
2023-07-04	Add namespace to streamFeatures struct	xengineering
	This prevents collisions.
2023-07-04	Re-implement SASL	xengineering
	Was broken because of switch to new RX concept.
2023-07-04	Introduce handle() as dummy	xengineering

2023-07-04	Implement XML element parsing with Generic	xengineering
	This helps to avoid duplicated code when new XML elements are described as custom structs.
2023-07-04	Rework routing completely	xengineering

2023-07-04	Further reduce complexity of streamFeatures struct	xengineering

2023-07-04	Just pass parsed data if successful	xengineering

2023-07-04	Reduce complexity of streamFeatures struct	xengineering

2023-07-04	First working version of new RX concept	xengineering
	This uses xml.Decoder.DecodeElement() which makes parsing way easier. This first step is just able to parse stream features partially.
2023-07-04	Remove unit test for router	xengineering
	The new router will be so trivial that it is not worth a unit test.
2023-07-04	Re-implement stream open and close	xengineering
	This is more suitable for the new RX concept.
2023-07-04	Remove xmpp.presence type	xengineering
	This was empty and has no benefit.
2023-07-04	Remove runStreamPair()	xengineering
	This will not be used in the new RX concept.
2023-07-04	Remove element_buffer	xengineering
	The new RX concept will not need such an element buffer and uses the xml.Decoder.DecodeElement() function instead.
2023-07-03	Remove encoderDecoder struct completely	xengineering
	This was not really necessary because it was all related to the xmpp.session and should thus be implemented there. Using the context package further reduced the complexity for cancelation.
2023-07-03	Move xml.Encoder to session struct	xengineering
	The encoderDecoder sub-struct of the session struct should be removed in little steps. This is the first one.
2023-07-03	Rename encoder_decoder.go to xml.go	xengineering
	This is way shorter and serves the same purpose: It reflects the responsibility of encoding and decoding XML. The encoderDecoder struct should be removed soon.
2023-07-03	Rename stream_pair.go to streams.go	xengineering
	The fact that it is actually about a pair of XML streams is obvious and not that relevant. A shorter name has a higher priority.
2023-07-03	Use xml.Encoder.EncodeElement() for presence	xengineering
	This required the trick of defining an empty struct as `presence` type but works pretty well. For sending data EncodeElement instead of token handling should always work. Since it is simpler it should be used.
2023-07-03	Switch to EncodeElement() for resource binding	xengineering

2023-07-03	Switch to EncodeElement() for SASL auth	xengineering

2023-07-01	Drop xml.{ProcInst,Directive,Comment}	xengineering
	LimoX does not care about these XML tokens at least for now. The issued error messages on other levels. Dropping those tokens on the encoderDecoder level asserts that the rest of the xmpp code has only `clean` XML content to process.
2023-07-01	Improve prefix and disable indent	xengineering
	The prefix has now more visual contrast to the XML content due to its own bracket style. Furthermore the indent for the TX stream was disabled. Indent is a nice thing but it just makes sense if both streams are indented identically. Since the RX stream received from the current development server has no indent and also no newlines it is better to turn it of completely. This might change in the future with structured logging (with the new slog package) or command line flags to toggle this behaviour. Re-encoding of the RX stream could also be an option but should stay one because it alters the RX stream and might hide errors during debugging.
2023-07-01	Add log module based XML logging with prefix	xengineering
	The prefix is re-implemented with this commit to distinguish between RX and TX XML. Furthermore the logging is now based on the log module to have the same (e.g. timestamp) prefix as other log messages.
2023-07-01	Implement byte-based logging for RX	xengineering
	This commit uses an io.TeeReader to achieve the same goal for RX like in the previous commit for TX.
2023-07-01	Implement byte-based logging for TX	xengineering
	Using an io.MultiWriter it is trivially possible to write encoded tokens to the TCP channel aswell as to stdout. The disadvantage is that it is not possible to inject prefix data like the so far used `C: ` only for stdout and not for the TCP channel. Such a prefix is not wanted in the TCP channel and thus not wanted for both. The solution to get a nice log is to implement a transparent logging middleware which gets the raw TX stream and inserts a prefix at each line before sending to stdout.
2023-06-30	Send initial presence after resource result	xengineering
	This completes the connection process.
2023-06-30	Apply go fmt	xengineering

2023-06-30	Add log-only handler for received IQ stanzas	xengineering
	This handler is just a placeholder for a more extensive IQ handling but already writes to the log so that it is obvious what is happening.
2023-06-30	Implement resource binding request	xengineering
	This is the first step of resource binding which is a mandatory part of establishing an XMPP connection.
2023-06-30	Implement detection of resource binding offer	xengineering
	This allows to trigger resource binding if the stream supports it.
2023-06-30	Apply go fmt	xengineering

2023-06-30	Implement basic handler for failed SASL auth	xengineering
	Writing to the log is still better than doing nothing ...
2023-06-30	Make streamFeaturesHandler() more generic	xengineering
	The new structure allows to check for different stream features and act according to them or - if nothing matches - do nothing apart from an error message to the log.
2023-06-30	Rework and apply stream nesting on SASL success	xengineering
	If SASL authentication is successful a new stream has to be opened by the client. This is implemented with this commit.