Abstraction of the TCP/IP stack like NetxDuo or LWIP example

[Zainulabedeen]

I was looking for a way to create a high level abstracted layer that can be agnostic to the lower layer TCP/IP stack, like NetxDuo or LWIP, running under the higher abstracted layer.

I have came across suggestion to implement a `plug-in` based implementation of the higher level abstracted layer.

Kindly suggest me your opinions, what could be the best way to implement such high level abstracted layer that can be agnostic to the lower level TCP/IP stack running ? Also if there is an example of someone doing something similar?

Thanks a lot. 

[MStackDev_376]

Hi,

Since you are looking for a high-level abstracted layer compatible with any lower layer TCP/IP, I would recommend you the Mongoose Networking Library.

Mongoose is a networking library ideal for embedded devices and it includes support for many networking protocols like HTTP, MQTT, Websockets and many more, with well documented APIs. At its core, it is the high-level abstraction library you are describing. It remains completely agnostic of any lower-layer TCP/IP implementation, having compatibility with numerous stacks (LwIP, NextDuo, any other stack that supports BSD sockets), also Mongoose comes with its own built-in lightweight stack as an alternative to the other stacks mentioned.

If you are looking to build your own layer, you can check at how Mongoose is implemented here. Or, if you would prefer to skip the implementation step, you can try and use Mongoose directly and see if it aligns with your goals. The library is well documented and it has lots of useful examples.

Heads up: I am part of the Mongoose development team, so I am very familiar with its design and features and I hope you find this helpful!

[Zainulabedeen]

Thanks for your reply, i appreciate it. However, i meant something that i wanted to directly abstract for instance the APIs provided by NetxDuo, LWIP etc. rather than abstracting them from very low level like their socket APIs. Is there an example or idea of that sort ?

[MStackDev_376]

Thanks for the clarification.

---

@Zainulabedeen wrote:

i wanted to directly abstract for instance the APIs provided by NetxDuo, LWIP etc. rather than abstracting them from very low level like their socket APIs

---

Just to make sure we are on the same page, do you mean you want to abstract the low-level Raw API (e.g. functions like tcp_*, udp_* for LwIP) instead of the socket API?

The socket API is the highest level api interface of the stack, whilst the Raw API is the lowest-level one, so I think it would make more sense to abstract the socket API to ensure portability across all other stacks. Raw API in LwIP has the Netconn API built on top of it, so you could take a look at that to get an idea of an example.

[sergey23]

What exactly are you trying to do? As is, your request makes little sense.

It looks like you have some sort of network library or application that you'd like to make crossplatform. Is that the goal? Unless you provide details, I am not sure your question can get any meaningful answer.

[Zainulabedeen]

I intend to develop an abstraction layer over the available TCP/IP stack. This layer will allow me to switch between NetX Duo and LwIP APIs through a configuration header file. The abstraction ensures that the APIs I design remain agnostic to the underlying stack, making the solution more portable. Importantly, my focus is not on starting to abstract the lower level TCP/UDP stack itself, but rather on creating higher-level APIs that sit above it like for example NetxDuo APIs for starting http server or LWIP APIs for starting https server.

[sergey23]

Thank you, that makes sense.

So, you're effectively looking to design a web server API, and implement it on top of NextDuo and LwIP.

That could be done of course. The aforementioned Mongoose is exactly like that - it provides a higher level HTTP API for different underlying TCP/IP implementations, including LWIP, NetxDuo and it's own built-in TCP/IP stack. You're basically looking to create Mongoose's alternative.