kandi X-RAY | phplinphone Summary
kandi X-RAY | phplinphone Summary
phplinphone is a C++ liblinphone library implementation, callable from PHP. Liblinphone is a high level library integrating all the SIP video calls feature into a single easy to use API. If you want to know a bit more about linphone and liblinphone, you can visit linphone website:
Top functions reviewed by kandi - BETA
phplinphone Key Features
phplinphone Examples and Code Snippets
Trending Discussions on TCP
I am using
buffio.Writer in GoLang as follows.
ANSWERAnswered 2022-Mar-22 at 14:14
There are two cases to note here.
If you want to have per
write() deadline, then its not possible to use buffering. When you use buffering, then the actual
write() is triggered when the buffer is full. So technically its not possible to know when your
write() is completed. In this case, you are essentially using
conn.write() and you can use
conn.SetWriteDeadline(time.Now().Add(n * time.Second)).
In the second case, as @icza has mentioned in the comment, you can set the deadline in the underlying
conn object, and the buffio.writer() wrapper will adhere to this rule. While this is semantically correct, it doesn't provide the networking abstraction you want.
I am currently working on a blazor server project which will display information from modbus tcp/ip devices. I have a class called "DeviceModel" which models a Modbus device. A simplified example is shown below....
ANSWERAnswered 2022-Mar-12 at 18:38
Or does it make more sense to keep NetworkAccess and DeviceModel separate?
The single-responsibility principle (SRP) is a computer-programming principle that states that every module, class or function in a computer program should have responsibility over a single part of that program's functionality, and it should encapsulate that part. All of that module, class or function's services should be narrowly aligned with that responsibility.
Read more about single responsibility principle of SOLID here.
So making separate method
Device class is more preferable for me.
It is hard to say whether my refactoring code is appropriate to you, but I tried to do my best:
I'm aware that the
::send within a Linux TCP server can limit the sending of the payload such that
::send needs to be called multiple times until the entire payload is sent.
i.e. Payload is 1024 bytes
sent_bytes = ::send(fd, ...) where
sent_bytes is only 256 bytes so this needs to be called again.
Is there any way to know exactly how many bytes can be sent before sending? If the socket will allow for the entire message, or that the message will be fragmented and by how much?
2 messages are sent to the same socket by different threads at the same time on the same tcp client via
::send(). In some cases where messages are large multiple calls to
::send() are required as not all the bytes are sent at the initial call. Thus, go with the loop solution until all the bytes are sent. The loop is mutexed so can be seen as thread safe, so each thread has to perform the sending after the other. But, my worry is that beacuse Tcp is a stream the client will receive fragments of each message and I was thinking that adding framing to each message I could rebuild the message on the client side, if I knew how many bytes are sent at a time.
Although the call to
::send() is done sequentially, is the any chance that the byte stream is still mixed?
Effectively, could this happen:
- Server Side
- Message 1: "CiaoCiao"
- Message 2: "HelloThere"
- Client Side
- Received Message: "CiaoHelloCiaoThere"
ANSWERAnswered 2022-Feb-21 at 00:28
Although the call to ::send() is done sequentially, is the any chance that the byte stream is still mixed?
Of course. Not only there's a chance of that, it is pretty much going to be a certainty, at one point or another. It's going to happen at one point. Guaranteed.
sent to the same socket by different threads
It will be necessary to handle the synchronization at this level, by employing a mutex that each thread locks before sending its message and unlocking it only after the entire message is sent.
It goes without sending that this leaves open a possibility that a blocked/hung socket will result in a single thread locking this mutex for an excessive amount of time, until the socket times out and your execution thread ends up dealing with a failed
write(), in whatever fashion it is already doing now (you are, of course, checking the return value from send/write, and handling the exception conditions appropriately).
There is no single, cookie-cutter, paint-by-numbers, solution to this that works in every situation, in every program, that needs to do something like this. Each eventual solution needs to be tailored based on each program's unique requirements and purpose. Just one possibility would be a dedicated execution thread that handles all socket input/output, and all your other execution threads sending their messages to the socket thread, instead of writing to the socket directly. This would avoid having all execution thread wedged by a hung socket, at expense of grown memory, that's holding all unsent data.
But that's just one possible approach. The number of possible, alternative solutions has no limit. You will need to figure out which logic/algorithm based solution will work best for your specific program. There is no operating system/kernel level indication that will give you any kind of a guarantee as to the amount of a
write() call on a socket will accept.
I want to
subscribe a to a
pub-socket on a server that implements ZeroMQ (https://zeromq.org/)
My final product will be a flutter app. It must be running on Android/iOS/Windows/MacOS/Linux/Web. So I'm really careful with the plugin-choice. I do not want to burden myself with an intense amount of platform-specific code, neither do I want to be dependent on plugins that might
break under certain conditions on each platform.
I know that there is a ZeroMQ-Plugin, but it has some Unresolved Issues in terms of operability on different platforms. Also I tried to run it on different Windows-machines and it only worked in about 25% of the cases.
Here's the fundamental network-communication between App and Server (see image below).
Is it possible to connect to a ZeroMQ-Publisher-Socket WITHOUT implementing or depending on the C++ compiled file of ZeroMQ? I'm thinking of a
WebSocket, but I'm not even sure if it's technically possible (protocol etc), as I think that ZeroMQ uses it's own protocoll (please verify).
Can I subscribe to a ZeroMQ-Publisher-Socket with
WebSockets in Flutter? If yes, how? Are there alternatives?
ANSWERAnswered 2022-Feb-17 at 19:36
"Is it possible to connect to a ZeroMQ-Publisher-Socket WITHOUT implementing or depending on the C++ compiled file of ZeroMQ?"
Yes, it is. It is quite enough to re-implement the published ZeroMQ ZMTP RFC-s relevant for the use-case & your code is granted to become interoperable, irrespective of the implementation language / deployment ecosystem, if it meets all the ZMTP RFC-s' mandatory requirements. So it is doable.
"... ZeroMQ uses it's own protocoll (please verify)."
No, in the sense of OSI-ISO-L2/L3 stack.
Yes, in the sense of higher layer application-driven protocols, where the ZMTP RFC-s apply for the most of the ZeroMQ Scalable Formal Communication Patterns' Archetypes ( may read more on ZeroMQ sockets are not sockets as you know them ), yet there are also tools to interface with O/S plain-sockets'
fd-s, where needed. Still A1 applies here.
"Can I subscribe to a ZeroMQ-Publisher-Socket with ...? If yes, how?"
Yes, it possible when your code follows the published ZMTP RFC-s. Implement all ZMTP RFC-s' mandatory properties & you are granted an interoperability with any other, ZeroMQ-ZMTP-RFC-s' compliant, node.
"Are there alternatives?"
Yes, if your design can extend the Server-side, adding another AccessPoint-s there, using
ZMQ_STREAM Scalable Formal Communication Archetype there, may reduce your Flutter-side scope of ZMTP RFC-s needed, as interfacing to native plain-socket will be the only one to handle and the "functionality gap" thereof can be handled on the Server-side of the link ( easily handling all the subscription management & message filtering, that must meet the ZeroMQ ZMTP RFC-s, so why not tandem it inside the Server-side before connecting the down-stream to Flutter App - smart, isn't it? )
I am creating a TCP connection from my linux program with boost.asio. I wonder how do I get the value of its congestion window (cwnd) from the program? The only way I know of is to parse
/proc/net/tcp, but this does not feel right. I'd rather use a dedicated syscall to get this info.
A solution to a similar question (How to monitor cwnd and ssthresh values for a TCP connection?) suggests using TCP Probe, but it feels even less appealing.
So what is the best way to get the value of cwnd?...
ANSWERAnswered 2022-Jan-21 at 17:00
I'm trying to create a reverse proxy to a CONNECT-based HTTP proxy. The user who wants to use the proxy just treats
machine A as an HTTP proxy. It works the following way:
machine Bopens a TCP socket to
machine A, a TCP socket is exposed on a port and all the incoming data is tunneled to
machine B, all the data is tunneled to the local HTTP server and the socket to
Essentially this is a reverse-proxy behind an HTTP proxy. The reason it's this complex is because the HTTP proxy is behind NAT (on
machine B) and therefore not accessible directly. The use case is being able to host an HTTP proxy behind a NAT.
Machine A tunnel (Go):...
ANSWERAnswered 2022-Jan-10 at 19:54
When you do
I want my TCP client to connect to multiple servers(each server has a separate IP and port).
I am using async_connect. I can successfully connect to different servers but the read/write fails since the server's corresponding tcp::socket object is not available.
Can you please suggest how I could store each server's socket in some data structure? I tried saving the IP, socket to a std::map, but the first server's socket object is not available in memory and the app crashes.
I tried making the socket static, but it does not help either.
Please help me!!
Also, I hope I am logically correct in making a single TCP client connect to 2 different servers. I am sharing below the simplified header & cpp file....
ANSWERAnswered 2021-Dec-14 at 12:00
You seem to know your problem: the socket object is unavailable. That's 100% by choice. You chose to make it static, of course there will be only one instance.
Also, I hope I am logically correct in making a single TCP client connect to 2 different servers.
It sounds wrong to me. You can redefine "client" to mean something having multiple TCP connections. In that case at the very minimum you expect a container of
tcp::socket objects to hold those (or, you know, a
Connection object that contains the
For fun and glory, here's what I think you should be looking for.
- no more new, delete
- no more void*, reinterpret casts (!!!)
- less manual buffer sizing/handling
- no more
- buffer lifetimes are guaranteed for the corresponding async operations
- message queues per connection
- connections are on a strand for proper synchronized access to shared state in multi-threading environments
- I added in a connection max idle time timeout; it also limits the time taken for any async operation (connect/write). I assumed you wanted something like this because (a) it's common (b) there was an unused
deadline_timerin your question code
Note the technique of using shared pointers to have
Comm manage its own lifetime. Note also that
_outbox are owned by the individual
In a python3/mininet script I have a tested, valid dictionary of host machines and their IP addresses.
For each of the keys - by iterating
dictOfAllHostsAndIPs.keys() - I execute a script on each emulated host's terminal
ANSWERAnswered 2021-Dec-05 at 11:04
I think I see what is going on in the source, but i have not run the framework to confirm it.
It looks like mininet inatalls a NAT rule for every node:
I am looking for a basic thing yet I have not found not even a single good documentation on getting it done.
I want to allocate a floating IP, then associate it to a network interface of a droplet other than eth0. The reason is I want to have the ability to very easily switch from one IP to the other with a programming language.
In a few words, I want to be able to do these two commands and both should provide a different response....
ANSWERAnswered 2021-Nov-27 at 00:12
In the cloud (AWS. GCP etc.) ARP is emulated by the virtual network layer, meaning that only IPs assigned to VMs by the cloud platform can be resolved. Most of the L2 failover protocols do break for that reason. Even if ARP worked,the IP allocation process for these IPs (often called “floating IPs”) would not integrate with the virtual network in a standard way, so your OS can't just "grab" the IP using ARP and route the packets to itself.
I have not personally done this on Digital Ocean, but I assume that you can call the cloud's proprietary API to do this functionality if you would like to go this route.
See this link on GCP about floating IPs and their implementation. Hope this is helpful.
Here's an idea that needs to be tested:
- Let's say you have Node1(10.1.1.1/24) and Node2(10.1.1.2/24)
- Create a loopback interface on both VMs and set the same IP address for both like (10.2.1.1/32)
- Start a heartbeat send/receive between them
- When NodeA starts it automatically makes an API call to create a route for 10.2.1.1/32 and points to itself with preference 2
- When NodeB starts it automatically makes an API call to create a route for 10.2.1.1/32 and points to itself with preference 1
- The nodes could monitor each other to withdraw the static routes if the other fails. Ideally you would need a 3rd node to reach quorum and prevent split brain scenarios, but you get the idea right?
I am trying to use ZMQ to connect many publishers to one subscriber (python). This is one such publisher (I use connect instead of bind because the subscriber binds). The code works fine until I unblock the commented code below.
I then receive this error on Windows:...
ANSWERAnswered 2021-Sep-27 at 07:59
This seems to be at least in part a bug (or difficult to understand behavior) so I suggest you create an issue on the repo. Perhaps it's related to: Test Error: Assertion failed: Socket operation on non-socket #147.
However, we can do our best to try to understand what's gone wrong and perhaps find a workaround. Since ZMQ.jl uses libzmq to handle sockets on a low level it might interfere with Julia's handling of file descriptors, we may have a race condition. Let's test that hypothesis by modifying your code a bit:
No vulnerabilities reported
Reuse Trending Solutions
Subscribe to our newsletter for trending solutions and developer bootcamps
Share this Page