UDP transfer using LBNet, not being recieved.

[Tasp]

Hi all,

I am finding txing UDP data rather sporadic. I know its a fire and forget protocol but so far I haven't had any issues if I rx data first, then return to the same IP and port. However this is opening then sending, doesn't require a response or an ACK.

The code below sits as a standalone EXE and waits for LB to run it and pass a string$ using CommandLine$ (this bit works).
It then parses that CommandLine and decides whether it's Serial, UDP or TCP (TCP not added yet....).

For testing this currently tx's the data to another Serial/UDP/TCP test program Hercules, it's running on the same computer, I thought originally the issue could be that it's because it's on the same machine, however, I'm able to consistently send UDP data from Packet Sender using the same details. IE. I can constantly hit the send button on Packet Sender and it's rx'd on Hercules everytime, doesn't miss a beat.

This code however only seems to be rx'd 6-8 times out of 10, sometimes less.



'NOMAINWIN

GLOBAL LBNETpath$

'Uncomment this line out when testing
CommandLine$ = "IPU%192.168.0.39%8000%THIS IS A TEST MESSAGE"


'LBNETpath$ = "\Lib\CoreL\LBNet.dll"
LBNETpath$ = "LBNet.dll"

WindowTitle$ = "Integration - "

PRINT CommandLine$
Type$ = LEFT$(CommandLine$, 3)

'If window is lauched without any data display an error
IF Type$ = "" THEN
   PRINT "Invalid argument!"
   NOTICE WindowTitle$ + CHR$(13) + "Invalid Argument!"
END IF

'***********************************************************COM PORT************************************************
'RS232
'Structure = COM4%baud%parity%data%stop%messsagetext
IF Type$ = "COM" THEN
   'Comm device
   ONCOMERROR [COMERR]
   token$ = "{"
   idx = 0
   WHILE token$<>""
       idx = idx + 1
       token$ = word$(CommandLine$, idx, "%")
       IF token$ <> "" THEN
           IF idx = 1 THEN Comport$ = token$
           IF idx = 2 THEN Baud$ = token$
           IF idx = 3 THEN Parity$ = token$
           IF idx = 4 THEN Databits$ = token$
           IF idx = 5 THEN Stopbits$ = token$
           IF idx = 6 THEN Message$ = afterlast$(CommandLine$, "%")
           print token$
       END IF
   WEND

CommInfo$ = Comport$ + ":" + Baud$ + "," + Parity$ + "," + Databits$ + "," + Stopbits$ '+ "," + "ds0,cs0,rs"
PRINT CommInfo$, Message$

'Open RS232 port and send info
OPEN CommInfo$ FOR RANDOM AS #com
#com, Message$;
CLOSE #com

PRINT "DONE!"
END

END IF

'********************************************************COM PORT FINISHED***************************************


'**********************************************************IP UDP START******************************************

'IP UDP

IF Type$ = "IPU" THEN
   'IP UDP

   'Collect information and parse into useable strings
   token$ = "{"
   idx = 0
   WHILE token$ <> ""
       idx = idx + 1
       token$ = word$(CommandLine$, idx, "%")
       IF token$ <> "" THEN
           IF idx = 2 THEN IP$ = token$
           IF idx = 3 THEN Port$ = token$
           'IF idx = 3 THEN
           print token$
       END IF
   WEND
   Message$ = afterlast$(CommandLine$, "%")

   'Open LBnet for UDP traffic
   CALL OpenLBNetDLL

'open UDP socket
[doOpen]
   hSock = UDPConnect(IP$, Port$, 0)
   if IsSocketInvalid(hSock) then
       print "Connect() failed. - ";GetError()
       goto [doEnd]
   end if

   'Collect length of data
   bufLen = LEN(Message$)

'Send the info to the port and IP specified
[doSend]
   PRINT "doOpen "; IP$, Port$, Message$

   sendNum = UDPSend(hSock, Message$, bufLen)

   IF sendNum = -1 THEN
       theError = GetError()
       PRINT "UDPSendTo() failed. - ";theError
       GOTO [doClose]
   END IF

'Close socket
[doClose]
   result = UDPClose(hSock)
   PRINT "Close result: "; result

'Close LBNet
[doEnd]
   CALL CloseLBNetDLL

'Close Program
END
END IF
'***********************************************************IP UDP END*******************************************

'***********************************************************IP TCP START*******************************************



'IP TCP
IF Type$ = "IPT" THEN
   'IP TCP




END IF

'***********************************************************IP TCP END*******************************************


'All conditions tested for so END program
PRINT "Operation Completed!"
END

'********************
'Error opening the RS232 port? Then just close the program.
[COMERR]
PRINT "Communications Error"
END
'********************

'====================
'==Helper Functions==
'====================
Sub OpenLBNetDLL
   open DefaultDir$ + LBNETpath$ for DLL as #LBNet
   a = InitLBNet()
End Sub

Sub CloseLBNetDLL
   a = EndLBNet()
   close #LBNet
End Sub

Function InitLBNet()
   CallDLL #LBNet, "InitLBNet",_
   InitLBNet as long
End Function

Function EndLBNet()
   CallDLL #LBNet, "EndLBNet",_
   EndLBNet as long
End Function

Function IsSocketInvalid(sock)
   CallDLL #LBNet, "IsSocketInvalid",_
   sock as ulong,_
   IsSocketInvalid as long
End Function

Function GetError()
   CallDLL #LBNet, "GetError",_
   GetError as long

   if GetError < 0 then
       GetError = (abs(GetError) XOR hexdec("FFFFFFFF")) + 1
   end if
End Function

Function UDPConnect(host$, srv$, msTimeout)
   CallDLL #LBNet, "UDPConnect",_
   host$ as ptr,_
   srv$ as ptr,_
   msTimeout as long,_
   UDPConnect as long
End Function

Function UDPConnectFrom(host$, srv$, msTimeout, localSrv$)
   CallDLL #LBNet, "UDPConnectFrom",_
   host$ as ptr,_
   srv$ as ptr,_
   msTimeout as long,_
   localSrv$ as ptr,_
   UDPConnectFrom as long
End Function

Function UDPSend(udpSock, buf$, bufLen)
   CallDLL #LBNet, "UDPSend",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   0 as long,_
   UDPSend as long
End Function

Function UDPSendTo(udpSock, buf$, bufLen, udpInfo$)
   CallDLL #LBNet, "UDPSend",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   udpInfo$ as ptr,_
   UDPSendTo as long
End Function

Function UDPClose(udpSock)
   CallDLL #LBNet, "UDPClose",_
   udpSock as long,_
   UDPClose as long
End Function

Function UDPGetInfoSize()
   CallDLL #LBNet, "UDPGetInfoSize",_
   UDPGetInfoSize as long
End Function

Function UDPReceive(udpSock, byref buf$, bufLen)
   CallDLL #LBNet, "UDPReceive",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   0 as long,_
   UDPReceive as long
End Function

Function UDPReceiveFrom(udpSock, byref buf$, bufLen, byref udpFrom$)
   udpFrom$ = space$(UDPGetInfoSize())

   CallDLL #LBNet, "UDPReceive",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   udpFrom$ as ptr,_
   UDPReceiveFrom as long
End Function

Function UDPIsReadAvailable(udpSock, msTimeout)
   CallDLL #LBNet, "UDPIsReadAvailable",_
   udpSock as long,_
   msTimeout as long,_
   UDPIsReadAvailable as long
End Function

Function UDPCreateListenSocket(pService$)
   CallDLL #LBNet, "UDPCreateListenSocket",_
   pService$ as ptr,_
   UDPCreateListenSocket as long
End Function


'include lb45func.bas


Code requires LBNet DLL by Chris Inverson API reference

[Tasp]

So I seem to have solved it.

EDIT: Scratch that, I thought I had it solved but managed not to save the working version or something as it's still doing the same thing.

It looks like LBNet needs a little time to finish opening the socket etc, this is probably Windoze needing the time, I don't know.

But if I add a Sleep call between opening the socket and sending the message I can get consistent results.

Here is a cut down version of the above code, with the Sleep set to 5.



NOMAINWIN

GLOBAL LBNETpath$

IP$ = "192.168.0.39"
Port$ = "8000"
Message$ = "THIS IS A TEST MESSAGE"


LBNETpath$ = DefaultDir$ + "\Lib\CoreL\LBNet.dll"
'LBNETpath$ = "LBNet.dll"


   'Open LBnet for UDP traffic
   CALL OpenLBNetDLL

'open UDP socket
[doOpen]
   hSock = UDPConnect(IP$, Port$, 0)
   IF IsSocketInvalid(hSock) then
       PRINT "Connect() failed. - ";GetError()
       GOTO [doEnd]
   ELSE
       PRINT "Connected, Socket ";hSock
   END IF

   'CALL Sleep 500

'Send the info to the port and IP specified
[doSend]
   PRINT "doOpen "; IP$, Port$, Message$

   CALL Sleep 5
'Collect length of data
   bufLen = LEN(Message$)
   sendNum = UDPSend(hSock, Message$, bufLen)

   IF sendNum = -1 THEN
       theError = GetError()
       PRINT "UDPSendTo() failed. - ";theError
       GOTO [doClose]
   END IF

'Close socket
[doClose]
   result = UDPClose(hSock)
   IF result = 0 THEN
       PRINT "Closed Socket"
   ELSE
       PRINT "Error when closing, "; result
   END IF

'Close LBNet
[doEnd]
   CALL CloseLBNetDLL

'Close Program
END


'====================
'==Helper Functions==
'====================
Sub OpenLBNetDLL
   open LBNETpath$ for DLL as #LBNet
   a = InitLBNet()
End Sub

Sub CloseLBNetDLL
   a = EndLBNet()
   close #LBNet
End Sub

Function InitLBNet()
   CallDLL #LBNet, "InitLBNet",_
   InitLBNet as long
End Function

Function EndLBNet()
   CallDLL #LBNet, "EndLBNet",_
   EndLBNet as long
End Function

Function IsSocketInvalid(sock)
   CallDLL #LBNet, "IsSocketInvalid",_
   sock as ulong,_
   IsSocketInvalid as long
End Function

Function GetError()
   CallDLL #LBNet, "GetError",_
   GetError as long

   if GetError < 0 then
       GetError = (abs(GetError) XOR hexdec("FFFFFFFF")) + 1
   end if
End Function

Function UDPConnect(host$, srv$, msTimeout)
   CallDLL #LBNet, "UDPConnect",_
   host$ as ptr,_
   srv$ as ptr,_
   msTimeout as long,_
   UDPConnect as long
End Function

Function UDPConnectFrom(host$, srv$, msTimeout, localSrv$)
   CallDLL #LBNet, "UDPConnectFrom",_
   host$ as ptr,_
   srv$ as ptr,_
   msTimeout as long,_
   localSrv$ as ptr,_
   UDPConnectFrom as long
End Function

Function UDPSend(udpSock, buf$, bufLen)
   CallDLL #LBNet, "UDPSend",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   0 as long,_
   UDPSend as long
End Function

Function UDPSendTo(udpSock, buf$, bufLen, udpInfo$)
   CallDLL #LBNet, "UDPSend",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   udpInfo$ as ptr,_
   UDPSendTo as long
End Function

Function UDPClose(udpSock)
   CallDLL #LBNet, "UDPClose",_
   udpSock as long,_
   UDPClose as long
End Function

Function UDPGetInfoSize()
   CallDLL #LBNet, "UDPGetInfoSize",_
   UDPGetInfoSize as long
End Function

Function UDPReceive(udpSock, byref buf$, bufLen)
   CallDLL #LBNet, "UDPReceive",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   0 as long,_
   UDPReceive as long
End Function

Function UDPReceiveFrom(udpSock, byref buf$, bufLen, byref udpFrom$)
   udpFrom$ = space$(UDPGetInfoSize())
   CallDLL #LBNet, "UDPReceive",_
   udpSock as long,_
   buf$ as ptr,_
   bufLen as long,_
   udpFrom$ as ptr,_
   UDPReceiveFrom as long
End Function

Function UDPIsReadAvailable(udpSock, msTimeout)
   CallDLL #LBNet, "UDPIsReadAvailable",_
   udpSock as long,_
   msTimeout as long,_
   UDPIsReadAvailable as long
End Function

Function UDPCreateListenSocket(pService$)
   CallDLL #LBNet, "UDPCreateListenSocket",_
   pService$ as ptr,_
   UDPCreateListenSocket as long
End Function

Sub Sleep ms
   CallDLL #kernel32, "Sleep",_
   ms as long,_
   ret as void
End Sub

'include lb45func.bas


[Chris Iverson]

Weird, I was testing this since your first post, and I have yet to see a single missed message, after hundreds of tries, and this is without adding the Sleep call.

If the sleep call gets things consistent, by all means keep it, but I'm not quite sure why it wouldn't actually be sending the data.

Are you running Windows 10?


EDIT: I made some rapid-fire tests just now. Looped the whole IPU section multiple times in a row, and each one came through.

[Tasp]

Yes running Win10.

But I seem to either posted non working code in the 2nd post or something else is going on. As now its doing the same thing. I'm 99% sure I posted it from the instance I was working from, but now that isn't working! ARGH!!!

I also have a Android phone running a UDP listener, which was also rxing the data ok, now that has stopped as well.

What made me go to the sleep, is if I stick a FOR NEXT loop when sending, it seems alot more consistent. All 10 messages are rx'd ok.

I'm missing something obvious.

[zxrportugal]

sending udp on lan with infinite loop add by me the original i think was writen by Brent Thorn
insert code here
[inicio]
y=y+1
open "WS2_32" for DLL as #winsock
calldll #winsock, "WSACleanup", ret as long
packet$ = str$(y)
ok = UDPsend("192.168.1.99", 9998, packet$)

if ok then print "Packet sent" else print "UDPsend failed"


for x=1 to 100
print x
next x
scan

goto [inicio]

end

function UDPsend(addr$, port, msg$)
AF.INET = 2
SOCK.DGRAM = 2
IPPROTO.UDP = 17
UDPsend = 0
port = (port and hexdec("FF00")) / 256 + (port and 255) * 256 ' swap bytes
calldll #winsock, "inet_addr", addr$ as ptr, ipaddr as ulong
struct WSAdata, d as char[398]
calldll #winsock, "WSAStartup", 514 as long, WSAdata as struct, ret as long
if ret then exit function
calldll #winsock, "socket", AF.INET as long, SOCK.DGRAM as long, _
IPPROTO.UDP as long, socket as long
if socket = -1 then exit function
struct addr, family as short, port as short, addr as ulong, zero as char[8]
addr.family.struct = AF.INET
addr.port.struct = port
addr.addr.struct = ipaddr
al = len(addr.struct)
ml = len(msg$)
calldll #winsock, "sendto", socket as long, msg$ as ptr, ml as long, _
0 as long, addr as struct, al as long, sent as long
calldll #winsock, "closesocket", socket as long, ret as long
calldll #winsock, "WSACleanup", ret as long
if sent = ml then UDPsend = 1
end function

[/code]

[Tasp]

Thanks and I've amended your code slightly, so it runs, but this is just as unreliable too.

LBNet with a FOR NEXT loop will produce always 1 to 10, But this won't, at best it produces 4 packets, unless you add a sleep or use the debugger then it produces 1 to 10.

I'm unsure where the issue lies here, whether it a PC config issue, using loopback IP, using a secondary device, it all provides an inconsistent result.

Disabled AV and firewall. Haven't checked Wireshark yet, but I reckon that's going to shows the packet not leaving LB.

It's very odd behaviour.


nomainwin

open "WS2_32" for DLL as #winsock

[inicio]

calldll #winsock, "WSACleanup", ret as long
packet$ = "THIS IS A TEST PACKET"

FOR a = 1 TO 10
   ok = UDPsend("192.168.0.40", 8000, STR$(a) + packet$)
NEXT

if ok then print "Packet sent" else print "UDPsend failed"

close #winsock

end

function UDPsend(addr$, port, msg$)
   AF.INET = 2
   SOCK.DGRAM = 2
   IPPROTO.UDP = 17
   UDPsend = 0
   port = (port and hexdec("FF00")) / 256 + (port and 255) * 256 ' swap bytes
   calldll #winsock, "inet_addr", addr$ as ptr, ipaddr as ulong
   struct WSAdata, d as char[398]
   calldll #winsock, "WSAStartup", 514 as long, WSAdata as struct, ret as long
   if ret then exit function
   calldll #winsock, "socket", AF.INET as long, SOCK.DGRAM as long, _
   IPPROTO.UDP as long, socket as long
   if socket = -1 then exit function
   struct addr, family as short, port as short, addr as ulong, zero as char[8]
   addr.family.struct = AF.INET
   addr.port.struct = port
   addr.addr.struct = ipaddr
   al = len(addr.struct)
   ml = len(msg$)
   calldll #winsock, "sendto", socket as long, msg$ as ptr, ml as long, _
   0 as long, addr as struct, al as long, sent as long
   calldll #winsock, "closesocket", socket as long, ret as long
   calldll #winsock, "WSACleanup", ret as long
   if sent = ml then UDPsend = 1
end function


[Chris Iverson]

Hmm, there's actually one thing I can think of that might be causing this.

You're opening and closing WinSock as fast as you can.

Part of the WinSock teardown process is clearing up any lingering data.

If it's data still waiting to send, for TCP connections, it will try to make sure the data is sent when the socket is closed.

For UDP connections, if data is still waiting to be transferred in a buffer, since UDP is explicitly unreliable anyway, I think it may just abandon the attempt to send when tearing down WinSock for the process.


Out of curiosity, try altering that program to do WSAStartup before the loop, and WSACleanup after the loop, and see if you still have data being abandoned.

[zxrportugal]

hi
yeap i think opening and closing winsock isn´t good idea, the original program doens´tt have the infinite loop,
but i tested whith the smart phone app in LAN and it works well .
but one thing is that liberty basic cold deal with winsock and we have many examples of programs written in c++ in the NET,many expressions are similar but...
my problem is i don´t now how convert him to LB
for example :
we need to put the socket in unblock mode in some cases , using select function...

in c ++ :

int WSAAPI select(
int nfds,
fd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
const timeval *timeout
);

see docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-select

how to convert this to lbb ?

[zxrportugal]

Copy from the c++ forum :

"Solution 2
You can decide if you want to use the socket as blocking, or nonblocking. Here is the code that switches between the 2 modes:

Copy Code
inline bool SetSocketBlocking(SOCKET sock, bool blocking)
{
unsigned long nonblocking_long = blocking ? 0 : 1;
if (ioctlsocket(sock, FIONBIO, &nonblocking_long) == SOCKET_ERROR)
return false;
return true;
}


If you use 1 listener/accepter thread in your server program and 1 thread per client with simple protocol, then its much easier to use blocking sockets I think. If you want an IO model where there are no threads per client but rather there is a "reactor" design pattern implementation where 1 thread (or sometimes more) serves a lot of sockets, then its easier to use non-blocking sockets.
For blocking sockets all recv/send/connect/accept operations are blocking until the operation either failes or succeeds. For nonblocking sockets its more complicated, but none of the previously mentioned functions block. With nonblocking sockets you usually do the read/write operations by waiting for sockets to become readable or writeable by using APIs like the crossplatform select() method, or the windows specific WSAEventSelect() or some IO completion ports if you want an MMO server. For example if the socket becomes writeable you call send() on it, and send() will return how many bytes was it able to write out. If it was able to write all bytes, you can call it again until it returns with error. In case of an error you have to check WSAGetLastError() if its WSAEWOULDBLOCK, because it means that this isn't really an error, only the send buffer of the socket (within the OS) is full, and you should wait again for the socket to become writeable. You have to check for this with almost every socket operations in case of nonblocking sockets. Connecting and accepting are also returning immediately with nonblocking sockets. In case of connection you have to wait for the socket to become writeable with select() (if you use the berkeley API) to detect when the connection becomes complete, or it will return with an exception flag set from select() in case of error. Or you can use the windows specific WSAEventSelect() that has a specific flag for connection detection. Same with accept, you have to wait for the listen socket to become readable with select(), or if you prefer windows specific API then WSAEventSelect() has special flags for testing the "accept ready" state. Maybe the select() is easier to use for the first time that the other APIs, and its also cross-platform.

Socket programming/debugging can become very-very complicated... Good luck, and ask again is something isn't clear or goes wrong! "

[Chris Iverson]

Yeah, nonblocking stuff is some of the future work I was considering for LBNet.

Part of the reason I made LBNet was to simply the usage of the sockets API, specifically for LB. The sockets API is simple on the surface, but it requires a lot of pointer and struct manipulation that is unwieldy to do in LB directly.

While I don't (yet) have a resource for checking write availability (and therefore nonblocking for outgoing stuff), I do provide IsReadAvailable() for incoming stuff, both listening for/accepting connections and receiving data.

You'll note that, if you check the source of the IsReadAvailable() function (see below), that it's implemented as an instant-returning select() call on the specified socket, that checks the results of the select() to see if the socket is readable.

github.com/iversc/lbnet/blob/9e1f02bb2e1fbbe479bac26d74d050fc642d952f/LBNet/LBNet.cpp#L412

[Tasp]

Sorry, forgot to post the conclusion to this.

LBnet (as expected) works perfectly. And Chris, your thoughts about opening and closing was spot on.

The issue was. I was closing the socket too quickly, since it's UDP doesn't care if it was sent or not and was closing the socket before Windoze had a chance to do anything.

Adding a Sleep call 10ms, even 5 was enough, to allow it to process before closing the socket. Hence why it worked using a FOR NEXT loop.

I ended up with Sleeping for 10ms either side of sending, in case the PC was slow or busy doing something, not sure if this would need to be the case but 20ms in reality is nothing.

[Chris Iverson]

I'm not sure just closing the socket would cause the issue, but closing down WinSock would.

This is the most recent code you posted in this thread, altered slightly. Does this still demonstrate the behavior?


nomainwin

open "WS2_32" for DLL as #winsock

[inicio]

calldll #winsock, "WSACleanup", ret as long
packet$ = "THIS IS A TEST PACKET"

calldll #winsock, "WSAStartup", 514 as long, WSAdata as struct, ret as long
   if ret then end

FOR a = 1 TO 10
   ok = UDPsend("192.168.0.40", 8000, STR$(a) + packet$)
NEXT

if ok then print "Packet sent" else print "UDPsend failed"

calldll #winsock, "WSACleanup", ret as long

close #winsock

end

function UDPsend(addr$, port, msg$)
   AF.INET = 2
   SOCK.DGRAM = 2
   IPPROTO.UDP = 17
   UDPsend = 0
   port = (port and hexdec("FF00")) / 256 + (port and 255) * 256 ' swap bytes
   calldll #winsock, "inet_addr", addr$ as ptr, ipaddr as ulong
   struct WSAdata, d as char[398]
   calldll #winsock, "socket", AF.INET as long, SOCK.DGRAM as long, _
   IPPROTO.UDP as long, socket as long
   if socket = -1 then exit function
   struct addr, family as short, port as short, addr as ulong, zero as char[8]
   addr.family.struct = AF.INET
   addr.port.struct = port
   addr.addr.struct = ipaddr
   al = len(addr.struct)
   ml = len(msg$)
   calldll #winsock, "sendto", socket as long, msg$ as ptr, ml as long, _
   0 as long, addr as struct, al as long, sent as long
   calldll #winsock, "closesocket", socket as long, ret as long
   if sent = ml then UDPsend = 1
end function